基于人工蜂群算法的兵力投送

‘叁’ java人工蜂群算法求解TSP问题

一、人工蜂群算法的介绍

人工蜂群算法(Artificial Bee Colony, ABC)是由Karaboga于2005年提出的一种新颖的基于群智能的全局优化算法，其直观背景来源于蜂群的采蜜行为，蜜蜂根据各自的分工进行不同的活动，并实现蜂群信息的共享和交流，从而找到问题的最优解。人工蜂群算法属于群智能算法的一种。

二、人工蜂群算法的原理

1、原理

标准的ABC算法通过模拟实际蜜蜂的采蜜机制将人工蜂群分为3类: 采蜜蜂、观察蜂和侦察蜂。整个蜂群的目标是寻找花蜜量最大的蜜源。在标准的ABC算法中，采蜜蜂利用先前的蜜源信息寻找新的蜜源并与观察蜂分享蜜源信息；观察蜂在蜂房中等待并依据采蜜蜂分享的信息寻找新的蜜源；侦查蜂的任务是寻找一个新的有价值的蜜源，它们在蜂房附近随机地寻找蜜源。

假设问题的解空间是。

代码：

[cpp]view plain

‘肆’ 人工蜂群算法适合在srm中应用吗

蜜蜂是一种群居昆虫，虽然单个昆虫的行为极其简单，但是由单个简单的个体所组成的群体却表现出极其复杂的行为。真实的蜜蜂种群能够在任何环境下，以极高的效率从食物源（花朵）中采集花蜜；同时，它们能适应环境的改变。
蜂群产生群体智慧的最小搜索模型包含基本的三个组成要素：食物源、被雇佣的蜜蜂（employed foragers）和未被雇佣的蜜蜂（unemployed foragers）；两种最为基本的行为模型：为食物源招募（recruit）蜜蜂和放弃（abandon）某个食物源。
(1)食物源：食物源的价值由多方面的因素决定，如：它离蜂巢的远近，包含花蜜的丰富程度和获得花蜜的难易程度。使用单一的参数，食物源的“收益率”（profitability），来代表以上各个因素。
(2)被雇用的蜜蜂：也称引领蜂（Leader），其与所采集的食物源一一对应。引领蜂储存有某一个食物源的相关信息（相对于蜂巢的距离、方向、食物源的丰富程度等）并且将这些信息以一定的概率与其他蜜蜂分享。
(3)未被雇用的蜜蜂：其主要任务是寻找和开采食物源。有两种未被雇用的蜜蜂：侦查蜂（Scouter）和跟随蜂（Follower）。侦察蜂搜索蜂巢附近的新食物源；跟随蜂等在蜂巢里面并通过与引领蜂分享相关信息找到食物源。一般情况下，侦察蜂的平均数目是蜂群的5%-20%。

‘伍’ 人工蜂群算法matlab蜂群种群大小怎么设定

%/* ABC algorithm coded using MATLAB language */

%/* Artificial Bee Colony (ABC) is one of the most recently defined algorithms by Dervis Karaboga in 2005, motivated by the intelligent behavior of honey bees. */

%/* Referance Papers*/

%/*D. Karaboga, AN IDEA BASED ON HONEY BEE SWARM FOR NUMERICAL OPTIMIZATION,TECHNICAL REPORT-TR06, Erciyes University, Engineering Faculty, Computer Engineering Department 2005.*/

%/*D. Karaboga, B. Basturk, A powerful and Efficient Algorithm for Numerical Function Optimization: Artificial Bee Colony (ABC) Algorithm, Journal of Global Optimization, Volume:39, Issue:3,pp:459-171, November 2007,ISSN:0925-5001 , doi: 10.1007/s10898-007-9149-x */

%/*D. Karaboga, B. Basturk, On The Performance Of Artificial Bee Colony (ABC) Algorithm, Applied Soft Computing,Volume 8, Issue 1, January 2008, Pages 687-697. */

%/*D. Karaboga, B. Akay, A Comparative Study of Artificial Bee Colony Algorithm, Applied Mathematics and Computation, 214, 108-132, 2009. */

%/*Copyright ?2009 Erciyes University, Intelligent Systems Research Group, The Dept. of Computer Engineering*/

%/*Contact:
%Dervis Karaboga (karaboga@erciyes.e.tr )
%Bahriye Basturk Akay (bahriye@erciyes.e.tr)
%*/

clear all
close all
clc

%/* Control Parameters of ABC algorithm*/
NP=20; %/* The number of colony size (employed bees+onlooker bees)*/
FoodNumber=NP/2; %/*The number of food sources equals the half of the colony size*/
limit=100; %/*A food source which could not be improved through "limit" trials is abandoned by its employed bee*/
maxCycle=2500; %/*The number of cycles for foraging {a stopping criteria}*/

%/* Problem specific variables*/
objfun='Sphere'; %cost function to be optimized
D=100; %/*The number of parameters of the problem to be optimized*/
ub=ones(1,D)*100; %/*lower bounds of the parameters. */
lb=ones(1,D)*(-100);%/*upper bound of the parameters.*/

runtime=1;%/*Algorithm can be run many times in order to see its robustness*/

%Foods [FoodNumber][D]; /*Foods is the population of food sources. Each row of Foods matrix is a vector holding D parameters to be optimized. The number of rows of Foods matrix equals to the FoodNumber*/
%ObjVal[FoodNumber]; /*f is a vector holding objective function values associated with food sources */
%Fitness[FoodNumber]; /*fitness is a vector holding fitness (quality) values associated with food sources*/
%trial[FoodNumber]; /*trial is a vector holding trial numbers through which solutions can not be improved*/
%prob[FoodNumber]; /*prob is a vector holding probabilities of food sources (solutions) to be chosen*/
%solution [D]; /*New solution (neighbour) proced by v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) j is a randomly chosen parameter and k is a randomlu chosen solution different from i*/
%ObjValSol; /*Objective function value of new solution*/
%FitnessSol; /*Fitness value of new solution*/
%neighbour, param2change; /*param2change corrresponds to j, neighbour corresponds to k in equation v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij})*/
%GlobalMin; /*Optimum solution obtained by ABC algorithm*/
%GlobalParams[D]; /*Parameters of the optimum solution*/
%GlobalMins[runtime]; /*GlobalMins holds the GlobalMin of each run in multiple runs*/

GlobalMins=zeros(1,runtime);

for r=1:runtime

% /*All food sources are initialized */
%/*Variables are initialized in the range [lb,ub]. If each parameter has different range, use arrays lb[j], ub[j] instead of lb and ub */

Range = repmat((ub-lb),[FoodNumber 1]);
Lower = repmat(lb, [FoodNumber 1]);
Foods = rand(FoodNumber,D) .* Range + Lower;

ObjVal=feval(objfun,Foods);
Fitness=calculateFitness(ObjVal);

%reset trial counters
trial=zeros(1,FoodNumber);

%/*The best food source is memorized*/
BestInd=find(ObjVal==min(ObjVal));
BestInd=BestInd(end);
GlobalMin=ObjVal(BestInd);
GlobalParams=Foods(BestInd,:);

iter=1;
while ((iter <= maxCycle)),

%%%%%%%%% EMPLOYED BEE PHASE %%%%%%%%%%%%%%%%%%%%%%%%
for i=1:(FoodNumber)

%/*The parameter to be changed is determined randomly*/
Param2Change=fix(rand*D)+1;

%/*A randomly chosen solution is used in procing a mutant solution of the solution i*/
neighbour=fix(rand*(FoodNumber))+1;

%/*Randomly selected solution must be different from the solution i*/
while(neighbour==i)
neighbour=fix(rand*(FoodNumber))+1;
end;

sol=Foods(i,:);
% /*v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) */
sol(Param2Change)=Foods(i,Param2Change)+(Foods(i,Param2Change)-Foods(neighbour,Param2Change))*(rand-0.5)*2;

% /*if generated parameter value is out of boundaries, it is shifted onto the boundaries*/
ind=find(sol<lb);
sol(ind)=lb(ind);
ind=find(sol>ub);
sol(ind)=ub(ind);

%evaluate new solution
ObjValSol=feval(objfun,sol);
FitnessSol=calculateFitness(ObjValSol);

% /*a greedy selection is applied between the current solution i and its mutant*/
if (FitnessSol>Fitness(i)) %/*If the mutant solution is better than the current solution i, replace the solution with the mutant and reset the trial counter of solution i*/
Foods(i,:)=sol;
Fitness(i)=FitnessSol;
ObjVal(i)=ObjValSol;
trial(i)=0;
else
trial(i)=trial(i)+1; %/*if the solution i can not be improved, increase its trial counter*/
end;

end;

%%%%%%%%%%%%%%%%%%%%%%%% CalculateProbabilities %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%/* A food source is chosen with the probability which is proportioal to its quality*/
%/*Different schemes can be used to calculate the probability values*/
%/*For example prob(i)=fitness(i)/sum(fitness)*/
%/*or in a way used in the metot below prob(i)=a*fitness(i)/max(fitness)+b*/
%/*probability values are calculated by using fitness values and normalized by dividing maximum fitness value*/

prob=(0.9.*Fitness./max(Fitness))+0.1;

%%%%%%%%%%%%%%%%%%%%%%%% ONLOOKER BEE PHASE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

i=1;
t=0;
while(t<FoodNumber)
if(rand<prob(i))
t=t+1;
%/*The parameter to be changed is determined randomly*/
Param2Change=fix(rand*D)+1;

%/*A randomly chosen solution is used in procing a mutant solution of the solution i*/
neighbour=fix(rand*(FoodNumber))+1;

%/*Randomly selected solution must be different from the solution i*/
while(neighbour==i)
neighbour=fix(rand*(FoodNumber))+1;
end;

sol=Foods(i,:);
% /*v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) */
sol(Param2Change)=Foods(i,Param2Change)+(Foods(i,Param2Change)-Foods(neighbour,Param2Change))*(rand-0.5)*2;

% /*if generated parameter value is out of boundaries, it is shifted onto the boundaries*/
ind=find(sol<lb);
sol(ind)=lb(ind);
ind=find(sol>ub);
sol(ind)=ub(ind);

%evaluate new solution
ObjValSol=feval(objfun,sol);
FitnessSol=calculateFitness(ObjValSol);

% /*a greedy selection is applied between the current solution i and its mutant*/
if (FitnessSol>Fitness(i)) %/*If the mutant solution is better than the current solution i, replace the solution with the mutant and reset the trial counter of solution i*/
Foods(i,:)=sol;
Fitness(i)=FitnessSol;
ObjVal(i)=ObjValSol;
trial(i)=0;
else
trial(i)=trial(i)+1; %/*if the solution i can not be improved, increase its trial counter*/
end;
end;

i=i+1;
if (i==(FoodNumber)+1)
i=1;
end;
end;

%/*The best food source is memorized*/
ind=find(ObjVal==min(ObjVal));
ind=ind(end);
if (ObjVal(ind)<GlobalMin)
GlobalMin=ObjVal(ind);
GlobalParams=Foods(ind,:);
end;

%%%%%%%%%%%% SCOUT BEE PHASE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%/*determine the food sources whose trial counter exceeds the "limit" value.
%In Basic ABC, only one scout is allowed to occur in each cycle*/

ind=find(trial==max(trial));
ind=ind(end);
if (trial(ind)>limit)
Bas(ind)=0;
sol=(ub-lb).*rand(1,D)+lb;
ObjValSol=feval(objfun,sol);
FitnessSol=calculateFitness(ObjValSol);
Foods(ind,:)=sol;
Fitness(ind)=FitnessSol;
ObjVal(ind)=ObjValSol;
end;

fprintf('Ýter=%d ObjVal=%g\n',iter,GlobalMin);
iter=iter+1;

end % End of ABC

GlobalMins(r)=GlobalMin;
end; %end of runs

save all

‘陆’ 人工蜂群算法里太多比喻了，能不能就算法本身的步骤来讲讲

直接给你JAVA代码吧，看的简单易懂
import java.lang.Math;

public class beeColony {

/* Control Parameters of ABC algorithm*/
int NP=20; /* The number of colony size (employed bees+onlooker bees)*/
int FoodNumber = NP/2; /*The number of food sources equals the half of the colony size*/
int limit = 100; /*A food source which could not be improved through "limit" trials is abandoned by its employed bee*/
int maxCycle = 2500; /*The number of cycles for foraging {a stopping criteria}*/

/* Problem specific variables*/
int D = 100; /*The number of parameters of the problem to be optimized*/
double lb = -5.12; /*lower bound of the parameters. */
double ub = 5.12; /*upper bound of the parameters. lb and ub can be defined as arrays for the problems of which parameters have different bounds*/

int runtime = 30; /*Algorithm can be run many times in order to see its robustness*/

int dizi1[]=new int[10];
double Foods[][]=new double[FoodNumber][D]; /*Foods is the population of food sources. Each row of Foods matrix is a vector holding D parameters to be optimized. The number of rows of Foods matrix equals to the FoodNumber*/
double f[]=new double[FoodNumber]; /*f is a vector holding objective function values associated with food sources */
double fitness[]=new double[FoodNumber]; /*fitness is a vector holding fitness (quality) values associated with food sources*/
double trial[]=new double[FoodNumber]; /*trial is a vector holding trial numbers through which solutions can not be improved*/
double prob[]=new double[FoodNumber]; /*prob is a vector holding probabilities of food sources (solutions) to be chosen*/
double solution[]=new double[D]; /*New solution (neighbour) proced by v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) j is a randomly chosen parameter and k is a randomlu chosen solution different from i*/

double ObjValSol; /*Objective function value of new solution*/
double FitnessSol; /*Fitness value of new solution*/
int neighbour, param2change; /*param2change corrresponds to j, neighbour corresponds to k in equation v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij})*/

double GlobalMin; /*Optimum solution obtained by ABC algorithm*/
double GlobalParams[]=new double[D]; /*Parameters of the optimum solution*/
double GlobalMins[]=new double[runtime];
/*GlobalMins holds the GlobalMin of each run in multiple runs*/
double r; /*a random number in the range [0,1)*/

/*a function pointer returning double and taking a D-dimensional array as argument */
/*If your function takes additional arguments then change function pointer definition and lines calling "...=function(solution);" in the code*/

// typedef double (*FunctionCallback)(double sol[D]);

/*benchmark functions */

// double sphere(double sol[D]);
// double Rosenbrock(double sol[D]);
// double Griewank(double sol[D]);
// double Rastrigin(double sol[D]);

/*Write your own objective function name instead of sphere*/
// FunctionCallback function = &sphere;

/*Fitness function*/
double CalculateFitness(double fun)
{
double result=0;
if(fun>=0)
{
result=1/(fun+1);
}
else
{

result=1+Math.abs(fun);
}
return result;
}

/*The best food source is memorized*/
void MemorizeBestSource()
{
int i,j;

for(i=0;i<FoodNumber;i++)
{
if (f[i]<GlobalMin)
{
GlobalMin=f[i];
for(j=0;j<D;j++)
GlobalParams[j]=Foods[i][j];
}
}
}

/*Variables are initialized in the range [lb,ub]. If each parameter has different range, use arrays lb[j], ub[j] instead of lb and ub */
/* Counters of food sources are also initialized in this function*/

void init(int index)
{
int j;
for (j=0;j<D;j++)
{
r = ( (double)Math.random()*32767 / ((double)32767+(double)(1)) );
Foods[index][j]=r*(ub-lb)+lb;
solution[j]=Foods[index][j];
}
f[index]=calculateFunction(solution);
fitness[index]=CalculateFitness(f[index]);
trial[index]=0;
}

/*All food sources are initialized */
void initial()
{
int i;
for(i=0;i<FoodNumber;i++)
{
init(i);
}
GlobalMin=f[0];
for(i=0;i<D;i++)
GlobalParams[i]=Foods[0][i];

}

void SendEmployedBees()
{
int i,j;
/*Employed Bee Phase*/
for (i=0;i<FoodNumber;i++)
{
/*The parameter to be changed is determined randomly*/
r = ((double) Math.random()*32767 / ((double)(32767)+(double)(1)) );
param2change=(int)(r*D);

/*A randomly chosen solution is used in procing a mutant solution of the solution i*/
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
neighbour=(int)(r*FoodNumber);

/*Randomly selected solution must be different from the solution i*/
// while(neighbour==i)
// {
// r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
// neighbour=(int)(r*FoodNumber);
// }
for(j=0;j<D;j++)
solution[j]=Foods[i][j];

/*v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) */
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
solution[param2change]=Foods[i][param2change]+(Foods[i][param2change]-Foods[neighbour][param2change])*(r-0.5)*2;

/*if generated parameter value is out of boundaries, it is shifted onto the boundaries*/
if (solution[param2change]<lb)
solution[param2change]=lb;
if (solution[param2change]>ub)
solution[param2change]=ub;
ObjValSol=calculateFunction(solution);
FitnessSol=CalculateFitness(ObjValSol);

/*a greedy selection is applied between the current solution i and its mutant*/
if (FitnessSol>fitness[i])
{

/*If the mutant solution is better than the current solution i, replace the solution with the mutant and reset the trial counter of solution i*/
trial[i]=0;
for(j=0;j<D;j++)
Foods[i][j]=solution[j];
f[i]=ObjValSol;
fitness[i]=FitnessSol;
}
else
{ /*if the solution i can not be improved, increase its trial counter*/
trial[i]=trial[i]+1;
}

}

/*end of employed bee phase*/

}

/* A food source is chosen with the probability which is proportioal to its quality*/
/*Different schemes can be used to calculate the probability values*/
/*For example prob(i)=fitness(i)/sum(fitness)*/
/*or in a way used in the metot below prob(i)=a*fitness(i)/max(fitness)+b*/
/*probability values are calculated by using fitness values and normalized by dividing maximum fitness value*/
void CalculateProbabilities()
{
int i;
double maxfit;
maxfit=fitness[0];
for (i=1;i<FoodNumber;i++)
{
if (fitness[i]>maxfit)
maxfit=fitness[i];
}

for (i=0;i<FoodNumber;i++)
{
prob[i]=(0.9*(fitness[i]/maxfit))+0.1;
}

}

void SendOnlookerBees()
{

int i,j,t;
i=0;
t=0;
/*onlooker Bee Phase*/
while(t<FoodNumber)
{

r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
if(r<prob[i]) /*choose a food source depending on its probability to be chosen*/
{
t++;

/*The parameter to be changed is determined randomly*/
r = ((double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
param2change=(int)(r*D);

/*A randomly chosen solution is used in procing a mutant solution of the solution i*/
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
neighbour=(int)(r*FoodNumber);

/*Randomly selected solution must be different from the solution i*/
while(neighbour == i)
{
//System.out.println(Math.random()*32767+" "+32767);
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
neighbour=(int)(r*FoodNumber);
}
for(j=0;j<D;j++)
solution[j]=Foods[i][j];

/*v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) */
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
solution[param2change]=Foods[i][param2change]+(Foods[i][param2change]-Foods[neighbour][param2change])*(r-0.5)*2;

/*if generated parameter value is out of boundaries, it is shifted onto the boundaries*/
if (solution[param2change]<lb)
solution[param2change]=lb;
if (solution[param2change]>ub)
solution[param2change]=ub;
ObjValSol=calculateFunction(solution);
FitnessSol=CalculateFitness(ObjValSol);

/*a greedy selection is applied between the current solution i and its mutant*/
if (FitnessSol>fitness[i])
{
/*If the mutant solution is better than the current solution i, replace the solution with the mutant and reset the trial counter of solution i*/
trial[i]=0;
for(j=0;j<D;j++)
Foods[i][j]=solution[j];
f[i]=ObjValSol;
fitness[i]=FitnessSol;
}
else
{ /*if the solution i can not be improved, increase its trial counter*/
trial[i]=trial[i]+1;
}
} /*if */
i++;
if (i==FoodNumber-1)
i=0;
}/*while*/

/*end of onlooker bee phase */
}

/*determine the food sources whose trial counter exceeds the "limit" value. In Basic ABC, only one scout is allowed to occur in each cycle*/
void SendScoutBees()
{
int maxtrialindex,i;
maxtrialindex=0;
for (i=1;i<FoodNumber;i++)
{
if (trial[i]>trial[maxtrialindex])
maxtrialindex=i;
}
if(trial[maxtrialindex]>=limit)
{
init(maxtrialindex);
}
}

double calculateFunction(double sol[])
{
return Rastrigin (sol);
}
double sphere(double sol[])
{
int j;
double top=0;
for(j=0;j<D;j++)
{
top=top+sol[j]*sol[j];
}
return top;
}

double Rosenbrock(double sol[])
{
int j;
double top=0;
for(j=0;j<D-1;j++)
{
top=top+100*Math.pow((sol[j+1]-Math.pow((sol[j]),(double)2)),(double)2)+Math.pow((sol[j]-1),(double)2);
}
return top;
}

double Griewank(double sol[])
{
int j;
double top1,top2,top;
top=0;
top1=0;
top2=1;
for(j=0;j<D;j++)
{
top1=top1+Math.pow((sol[j]),(double)2);
top2=top2*Math.cos((((sol[j])/Math.sqrt((double)(j+1)))*Math.PI)/180);

}
top=(1/(double)4000)*top1-top2+1;
return top;
}

double Rastrigin(double sol[])
{
int j;
double top=0;

for(j=0;j<D;j++)
{
top=top+(Math.pow(sol[j],(double)2)-10*Math.cos(2*Math.PI*sol[j])+10);
}
return top;
}
}

使用方法是：
public class test {
static beeColony bee=new beeColony();

public static void main(String[] args) {
int iter=0;
int run=0;
int j=0;
double mean=0;
//srand(time(NULL));
for(run=0;run<bee.runtime;run++)
{
bee.initial();
bee.MemorizeBestSource();
for (iter=0;iter<bee.maxCycle;iter++)
{
bee.SendEmployedBees();
bee.CalculateProbabilities();
bee.SendOnlookerBees();
bee.MemorizeBestSource();
bee.SendScoutBees();
}
for(j=0;j<bee.D;j++)
{
//System.out.println("GlobalParam[%d]: %f\n",j+1,GlobalParams[j]);
System.out.println("GlobalParam["+(j+1)+"]:"+bee.GlobalParams[j]);
}
//System.out.println("%d. run: %e \n",run+1,GlobalMin);
System.out.println((run+1)+".run:"+bee.GlobalMin);
bee.GlobalMins[run]=bee.GlobalMin;
mean=mean+bee.GlobalMin;
}
mean=mean/bee.runtime;
//System.out.println("Means of %d runs: %e\n",runtime,mean);
System.out.println("Means of "+bee.runtime+"runs: "+mean);

}

}

‘柒’ 蜂群算法与人工蜂群算法有什么的区别吗

都是一样的，为什么有的会带上“人工”呢？只是因为这些只能算法都是“人”仿照动物行为而创造的，所以有时候才会带上“人工”两个字。但是指的是一个东西。
例如神经网络，也有人喜欢说是人工神经网络

‘捌’ 智慧工地中的图像传感技术的应用进展

本文内容来自以下文章：

杨晓娇,于忠,冮军.智慧工地中的图像传感技术的应用进展[J].四川建筑,2021,41(S1):41-44.

摘要：文章对智慧工地中的图像传感技术的发展历程、以及图像技术、视频技术、激光雷达点云技术在建筑工地中的应用作介绍，并介绍了智能算法在图像处理技术领域的发展应用。最后提出为了更好地满足施工监管的需求，图像技术可以通过视频技术、激光雷达点云技术在时间、空间上进行交叉验证，以提高图像识别的准确性。在智能算法与图像耦合技术方面应结合三维技术形成更加准确地实时反馈信号指导工程施工。

关键词：图像传感技术; 视频技术; 激光雷达点云技术; 智能算法

智慧工地和智慧建筑的兴起与当今智能化、信息化的发展有着紧密的联系。随着我国城镇化进程的加快，建筑施工过程日益复杂，施工现场安全问题，如劳务人员安全帽和安全绳佩戴、施工现场临时用电混乱、临边防护等问题，也日益凸显出来，使得传统施工安全监管技术已经无法满足目前现场施工安全的要求。借助计算机和人工智能技术的快速发展，图像传感技术凭借 处理精度高、灵活性强、再现性好、适用面广等特点 成功应用于建筑施工安全管理等过程，为项目管理人员提供施工现场的安全隐患、施工动态及进度的实时反馈，提高了建筑施工安全管理效率。

进入21世纪，图像传感技术的应用范围被逐渐拓宽，甚至在某些领域已经取得突破。然而，对计算机计算速度、存储容量要求较高，图像处理使用频带较宽、以及在成像、传输方面还有一定的技术难度等因素，制约了图像传感技术的进一步发展。

目前，智慧工地系统中包含了大量的各类传感器和核心的数据实时处理技术，也由此带来了大量的数据获取、传递和处理。随着智能技术的发展，视频图像信息在建筑信息数据中的占比越来越大，利用图像传感技术对建筑施工进度、人员安全带和防护栅栏等安全装置状态识别、工程质量评价以及施工现场扬尘监测等过程进行实时反馈，实现建筑施工过程中的信息识别、安全监管、决策分析等功能，使得图像传感技术成为建筑施工管理过程中的重要技术手段之一。

1 图像及视频传感技术在智慧工地中的应用

1.1 图像技术在建筑工地中的应用

图像技术总体上可以分为 图像分析、图像重建和图像的像质改善 三大部分，在建筑施工中图像技术一般用于图像分析，如人脸识别、安全帽/绳识别、火灾识别、混凝土结构监控等。

1. 2 视频技术在建筑工地的应用

建筑工地是一个复杂庞大的区域，利用视频技术对建筑物内部各个位置情况进行监管，对建筑施工现场安全管理进行实时监控。从现有的研究和应用案例来看，建筑工地对视频监控的需求主要集中在: 地基基础、地面施工、高层作业以及文明施工检查 等阶段。其中， 安全问题 是各个阶段最突出的问题之一，利用视频技术对施工现场的深基坑、高边坡支护安全、模板工程安全、临边洞口防护、脚手架搭设安全等过程进行监管，既减轻了监管人员的工作强度，又加强了建设行政主管部门以及监管机构的调控监控力度，提高了工作效率。

1.3 激光雷达点云技术在建筑工地的应用

近年来，利用激光雷达技术处理大规模的地理空间数据，发展了计算机视觉、计算机图形学。从有关于建筑重建、图像以及激光雷达建模的文献中发现，其中很大一部分内容致力于基于图像的方法进行 建筑重建 。激光雷达利用点云成型技术能快速获取大范围区域表面采样点的三维空间数据，正是由于其在建模工作上的高效性，因而在 建筑规划、建筑施工以及文物保护等 方面起到了重要作用。

2 智能算法对于图像技术在智慧建筑领域发展的影响

2.1 智能算法在图像处理技术中的发展

智能算法自提出以来就引起了国内外众多学者的广泛关注，经过多年的发展和创造，智能优化算法已成功应用在国民经济的各个领域，为生产生活中的许多复杂问题提供了一个高效可行的解决方案，成为了学术领域中一个重要的研究方向。其中比较经典的智能优化算法有: 遗传算法(GA)、蚁群算法(ACO)、粒子群算法(PSO)、差分进化算法(DE)、混合蛙跳算法(SFLA)、人工蜂群算法 等。 在图像处理技术上蚁群算法和粒子群算法是最常用的算法 。

总的来说，智能算法用于图像处理技术的优化具有两个方面的重要作用。 一是基于大数据信息平台的信息汇总数据智能处理分析，引导图像处理技术的优化和发展; 二是基于大数据技术对于数字信号的处理架构以及模型优化，能够有效辅助现有图像处理技术，实现图像处理技术的快速升级。

2.2 智能算法和图像耦合技术对传感建模方法的改进

利用 智能算法与图像耦合技术 处理施工过程中火灾识别、污染识别、劳务人员安全识别等问题具有高速、便捷等特点。智能算法与图像之间的耦合技术主要利用图像本身具有的张量结构，且张量结构具有良好的表达能力和计算特性，因此可以利用智能算法对张量结构进行分解并快速而高质量对图像进行压缩和提取相关特征信息，从而可以利用获取的信息进行快速的传感建模。施工现场的大气污染防治作为建筑工地的重要工作之一，利用图像处理技术对施工过程中的扬尘、裸土覆盖等问题进行智能识别，通过智能算法与图像之间的耦合技术对施工现场的扬尘、烟雾、裸土等信息进行提取传感建模，实现快速识别、抓取、处理等功能，并生成相应的数学模型对施工过程进行预测、评估等，指导施工现场管理。

然而，智能算法与图像耦合技术的传感建模方法仅仅是获取图像中的 二维数据信息 进行快速建模，对施工现场出现的问题作出的响应更多只是简单提取建模、分析、以及预警等，很难进一步提高精度。因此， 智能算法与图像之间的耦合技术应结合三维技术进行更加精确的数据信息提取，从而形成精度更高的实时反馈、预测模型、评价模型等指导现场施工实现精确识别、预测告警、以及深度治理等功能 。

3 总结和展望

本文主要对图像传感技术的发展历程，以及 图像技术、视频技术、激光雷达点云技术 在建筑中的应用进行了概述，指出随着建筑施工过程的日益复杂，建筑体量增大，仅仅依靠图像识别技术对劳务人员、安全帽佩戴、烟雾情况进行识别已经无法满足工地现场管理的要求，因此目前图像技术应与视频技术相结合，以提高图像识别的准确性。并提出利用激光雷达点云与视频图像技术对施工过程中的扬尘、裸土识别等进行交叉验证，以提高识别精度，实现建筑施工污染源的精准定位、智能预测、深度治理。文中还对智能算法、以及其在图像处理技术领域的应用进行了介绍，提出智能算法与图像耦合技术对于传感建模方法应结合三维技术进行更加精确的数据信息提取，从而形成精度更高的实时反馈、各类模型等指导现场工地施工。

‘玖’ 李俊杰的出版着作和论文

部分代表性论文如下： [1] Fei Kang, Junjie Li. Artificial bee colony algorithm optimized support vector regression for system reliability analysis of slopes. Journal of Computing in Civil Engineering, ASCE, 2015, Accepted. (SCI&EI)
[2] Fei Kang, Shaoxuan Han, Rodrigo Salgado, Junjie Li. System probabilistic stability analysis of soil slopes using Gaussian process regression with Latin hypercube sampling. Computers and Geotechnics
[3] Haojin Li, Junjie Li, Fei Kang. Application of the artificial bee colony algorithm-based projection pursuit method in statistical rock mass stability estimation. Environmental Earth Sciences
[4] Fei Kang, Junjie Li, Haojin Li, Artificial bee colony algorithm and pattern search hybridized for global optimization, Applied Soft Computing Top 25 Hottest Articles
[5] Fei Kang, Junjie Li, Zhenyue Ma. An artificial bee colony algorithm for locating the critical slip surface in slope stability analysis. Engineering Optimization
[6] Fei Kang, Junjie Li, Qing Xu. Damage detection based on improved particle swarm optimization using vibration data. Applied Soft Computing
[7] Fei Kang, Junjie Li, Zhenyue Ma. Rosenbrock artificial bee colony algorithm for accurate global optimization of numerical functions. Information Sciences,(SCI&EI) Most Cited Articles since 2010; Top 25 Hottest Articles
[8] Haojin Li, Junjie Li, Fei Kang. Risk analysis of dam based on artificial bee colony algorithm with fuzzy c-means clustering. Canadian Journal of Civil Engineering
[9] Zhou Hui, Li Jun-jie, Kang Fei. Distribution of acceleration and empirical formula for calculating maximum acceleration of rockfill dams. Journal of Central South University of Technology
[10] Fei Kang, Junjie Li, Qing Xu. Structural inverse analysis by hybrid simplex artificial bee colony algorithms. Computers & Structures, (SCI&EI) Most Cited Articles since
[11] Fei Kang, Junjie Li, Qing Xu. Virus coevolution partheno-genetic algorithms for optimal sensor placement. Advanced Engineering Informatics
[12] Wei Zeng, Junjie Li, and Fei Kang, Numerical Manifold Method with Endochronic Theory for Elastoplasticity Analysis, Mathematical Problems in Engineering
[13] Fei Kang, Junjie Li, Sheng Liu. Combined data with particle swarm optimization for structural damage detection. Mathematical Problems in Engineering, Volume
[14] Xu Wang, Fei Kang, Junjie Li, Xin Wang. Inverse parametric analysis of seismic permanent deformation for earth-rockfill dams using artificial neural networks. Mathematical Problems in Engineering, Volume [15] 仝宗良, 曾伟, 李俊杰. 基于数值流形法的土质边坡动力稳定性分析. 岩土工程学报
[16] 汪旭, 康飞, 李俊杰. 土石坝地震永久变形参数反演方法研究. 岩土力学
[17] 李浩瑾, 李俊杰, 康飞. 基于 LSSVM 的重力坝地震稳定易损性分析. 振动与冲击
[18] 李浩瑾, 李俊杰, 康飞, 张勇. 重力坝纵缝非连续接触的地震反应分析. 大连理工大学学报
[19] 周晖, 李俊杰, 康飞.面板堆石坝坝顶加速度沿坝轴线分布规律.岩土力学
[20] 康飞, 李俊杰, 许青. 混合蜂群算法及其在混凝土坝动力参数反演中的应用. 水利学报
[21] 康飞, 李俊杰, 许青. 堆石坝材料参数反演的蚁群聚类RBF网络模型. 岩石力学与工程学报
[22] 宋志宇，李俊杰，汪宏宇. 混沌人工鱼群算法在重力坝材料参数反演中的应用. 岩土力学
[23] 宋志宇，李俊杰. 基于微粒群算法的大坝材料参数反分析研究. 岩土力学
[24] 胡军, 李俊杰, 刘德志. 考虑剪切抗力的修正土钉单元及其应用. 岩土力学
[25] 刘德志, 李俊杰. 大坝安全监测资料的非线性检验, 应用基础与工程科学学报
[26] 刘德志, 李俊杰. 土石坝安全监测软件系统设计与实现，大连理工大学学报
[27] 杨清平, 李俊杰. 重力坝坝踵主拉应力区分布规律的探讨，水利学报
[28] 李俊杰，邵龙潭，邵宇. 面板堆石坝永久变形研究，大连理工大学学报
[29] 李俊杰, 马恒春. 蓄水期面板堆石坝动力特性研究. 岩土工程学报
[30] 李俊杰, 韩国城, 林皋. 混凝土面板堆石坝自振周期简化公式. 振动工程学报
[31] 李俊杰, 韩国城, 孔宪京. 关门山面板堆石坝三维地震反应分析. 水利学报
[32] 李俊杰, 孔宪京, 韩国城. 面板堆石坝动力破坏计算方法研究. 大连理工大学学报
[33] 李俊杰, 韩国城, 林皋. 混凝土面板堆石坝地震加速度反应规律的几点研究. 水利学报
[34] 孔宪京, 韩国城, 李俊杰. 关门山面板堆石坝二维地震反应分析. 大连理工大学学报
[35] 韩国城, 孔宪京, 李俊杰. 面板堆石坝动力破坏性态及抗震措施试验研究. 水利学报
[36] 孔宪京，韩国城，李俊杰，林皋. 防渗面板对堆石坝体自振特性的影响，大连理工大学学报 [37] 杨春雨, 李俊杰. 改进的 SSOR-PCG 快速求解法在高面板堆石坝求解效率和节约内存中的实践. 水电能源科学,
[38] 曾伟, 李俊杰. 基于 NMM-DDA 的直剪试验数值模拟. 水电能源科学
[39] 刘景, 李俊杰. 不同开度时溢流坝弧形闸门水流三维数值模拟. 水电能源科学
[40] 曾伟, 李俊杰. 基于数值流形法的土石坝静力计算数值模拟. 水利水电技术
[41] 宋宜祥, 李俊杰, 康飞. 虹吸井对尾矿坝地震液化的影响分析. 水电能源科学
[42] 康飞, 李俊杰, 马震岳. 基于人工蜂群算法的边坡最危险滑动面搜索. 防灾减灾工程学报
[43] 杨秀萍, 李俊杰, 康飞. 基于 ACC-RBF 的水布垭面板堆石坝参数反演分析. 水电自动化与大坝监测
[44] 李浩瑾, 李俊杰, 康飞. 基于 ABCA-LSSVM 的复杂工程结构可靠度计算. 水电能源科学
[45] 康飞, 李俊杰, 马震岳. 边坡稳定分析的差分进化全局求解. 水电能源科学
[46] 杜文才, 李俊杰. 贮灰坝安全预警模型研究. 水电能源科学
[47] 李浩瑾, 李俊杰, 康飞. 基于 PSO-AHP 的大坝致灾因子权重计算. 防灾减灾工程学报
[48] 胡峥嵘, 李俊杰. 面板堆石坝三维非线性有限元并行计算. 力学与实践
[49] 康飞，李俊杰，许青，张运花. 改进人工蜂群算法及其在反演分析中的应用. 水电能源科学
[50] 张运花，李俊杰，康飞. 西龙池面板堆石坝应力变形三维有限元分析. 水电能源科学，第
[51] 宋志宇，李俊杰. 基于模拟退火神经网络模型的岩质边坡稳定性评价方法. 长江科学院院报
[52] 李俊杰，胡军，康飞，王谊. 大顶子山溢流坝长闸墩温度应力仿真计算分析. 水电能源科学
[53] 康飞，马妹英，李俊杰. 支持向量回归在贮灰坝渗流监测中的应用. 水电自动化与大坝监测
[54] 宋志宇，李俊杰. 最小二乘支持向量机在大坝变形预测中的应用. 水电能源科学
[55] 张振国，李俊杰，杨晓明. 基于变分原理的三维土坡稳定分析方法研究及应用. 水电能源科学
[56] 刘德志,李俊杰,许青. 基于Internet-Intranet的火电厂贮灰坝自动化安全监测系统. 水电能源科学
[57] 李俊杰，马妹英，许青. RBF网络在贮灰坝浸润线预测中的应用. 水电能源科学
[58] 谭志军， 李俊杰. 混合遗传算法在贮灰坝监测系统上的应用. 水电能源科学
[59] 谭志军，李俊杰. BP 算法在贮灰坝监测系统中的应用. 水电自动化与大坝监测
[60] 费璟昊，李俊杰，李辉，杨建林. 利用图像处理实现隧洞测量. 测绘通报
[61] 李俊杰, 李黎, 许劲松等. 中远船坞抽水工程监测成果分析. 港口工程