数学建模社区-数学中国

标题: [求助]帮改一下程序 [打印本页]

---

作者: xiaolu1998    时间: 2005-2-28 14:23
标题: [求助]帮改一下程序
<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
( a+ y$ N% c7 t7 v7 t<>package ant;
7 r% y3 B: ^3 u/ I/*
* @(#)Antcolony.java 1.0 03/05/22
*
* You can modify the template of this file in the
* directory ..\JCreator\Templates\Template_2\Project_Name.java
' v2 D& ]7 L) F' ~2 N; \9 I# j *
* You can also create your own project template by making a new
* folder in the directory ..\JCreator\Template\. Use the other
' a8 P& G% @* M2 ^" R2 n * templates as examples.
! _' e1 @3 L  z2 Z7 @. U *
*/</P>
<>import java.awt.*;
% M+ s6 A% v0 r2 G) ^. N. Vimport java.applet.*;
import java.awt.event.*;
; g  V# ^, [. p; G' r% @: k" ^1 @import java.util.Vector;</P>
5 Q- N( k6 P- d# N<>class AntCanvas extends Canvas
+ |& n7 B! E: ]{
    //画布，一切画图操作均由该类完成
//Image image;
! M- G% G# K6 K; m( f- o/ F/ X Color obs_color;//障碍物颜色
' [% a7 M$ t9 u  o3 q Color origin_color;//我的颜色
Color back_color;//背景色
' m  l. d/ G* T( H: a. R" j        Color end_color;//食物点的颜色
. z' g2 h' ?* S- |( H$ N //boolean first;
) |' |' q( o1 H  p boolean reset;</P>
3 g6 B' d. V% K" B<>/* public AntCanvas(Image img) {</P>
7 \* F3 H) @* c% @/ w# y<>  super();
   image = img;
  obs_color = Color.white;
( N8 d+ R# v+ k  setBackground(Color.black);
  setForeground(Color.white);
  first = true;
  reset = false;</P>
<> }*/</P>
6 `# V- q; s  M" F<> public AntCanvas() {</P>
! x+ R) y; U( ~8 ~# ~) N; }! P<>  super();
   //image = null;
   back_color=Antcolony.BACK_COLOR;
& D1 x0 w0 M6 F: P5 j/ S5 m- F1 x% P  setBackground(back_color);
  _5 n2 t6 G9 h3 T! u  setForeground(Color.white);
  obs_color = Antcolony.OBS_COLOR;
  origin_color=Antcolony.ORIGIN_COLOR;
                end_color=Antcolony.End_COLOR;
% C! B1 M7 E0 R- C  //first = true;
9 w4 f0 j" @% `) w  reset = true;</P>
) p& r) W* G# \3 ^<> }</P>
+ m& P: Z1 m' [* H' B<> public void Clear() {
        //清空画布
  reset = true;
8 @" H. S2 Q, s7 {9 v6 ]  repaint();
' N6 T1 U$ r9 G9 v  [) j }</P>
<>
: J/ F- m: d. ~+ h1 u# ]* i1 B( U public void paint(Graphics g) {
  int i;
5 \) D- T0 i( F9 H0 d. {                //重画的时候仅仅画障碍物
/ A4 V' u9 P% w& v( r5 _  g.setColor(Color.black);
; C5 T. C- u$ p  g.fillRect(0,0,size().width,size().height);
  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
( H$ D  ]2 {' m8 P   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
8 V# q- S( h5 _; }  }</P>
<> }
public void process(){
2 R3 p  w3 h1 u( W        //处理动画的过程
; i+ a) }8 X9 `! w$ c  Graphics g=this.getGraphics();
                g.setColor(end_color);
# Q, [6 ]: j! V* w6 r   for(int j=0;j&lt;Antcolony.EndPts;j++){
0 |& _+ x8 h- u; ^                  //画所有的食物点
                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
                  //每只蚂蚁开始决策，并画蚂蚁
1 G& t& z; p: U! W' ^+ I: R, M. d   Antcolony.ants.Process();
! A' j  d" b1 [* K0 B/ h   Antcolony.ants.Draw(g);
  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
& c& D# c  N% j! A2 x) s" }( u                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
                        case (1):
) ]; D6 g8 N. I7 h                            v.Draw(g);
                            break;
                        case (2):
; ~% j. B5 a9 L6 ?# _% d- k                            if(v.kind==1)v.Draw(g);
3 m* R  M2 s0 q& B                            break;
                        case (3):
                            if(v.kind==0)v.Draw(g);
                            break;
                        }
                        v.delimit(g);
' M- q9 n$ ?/ p8 l3 |- l                }
           g.setColor(origin_color);
9 `: ]- G% L6 U$ U$ h; A                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
/ X) F) o6 T/ B! o                }</P>
; E' F; M+ H; d% m1 o. M<> }
7 ~, L  g7 s* Z1 a% u Graphics GetGra() {</P>
) [/ z# x7 ]7 i9 f<>  return this.getGraphics();
}
}
public class Antcolony extends Applet  implements Runnable  {
, C7 F1 d6 }" a  E/ ] boolean isStandalone = false;//系统的参数，是否独立运行，不用管
  o" m9 \7 ~6 n2 \ Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
. D5 a5 f4 K0 y' } static Color OBS_COLOR=Color.red;//障碍物的颜色
static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
1 v: |2 x# E. X. U static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
AntCanvas canvas=new AntCanvas();//画图用的画布
/ w$ k: m/ B3 B. x! Z* g( @- e int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
+ D( f$ E" s# G/ v3 O5 }        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
9 H* Z. v% X& Y, E' | static Point OriginPt[];//窝点信息
- @: z' J7 v3 r5 \, N6 l        static int OriginPts=1;//窝的个数，最大为100
: \% v3 K* l* n" U7 \& Z+ c% S0 b$ | static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
        static int FoodR=10;//食物和窝产生梯度的信息素的半径
static ant ants[];//蚂蚁数组
# t+ k6 L8 s; k( O! v        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
- |% N8 b* T2 y! [" F' V int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
$ i) Q. o2 ^$ L. _6 h! X! s        Button btnReset=new Button("重来");
0 f5 p( Y7 ]: R        Button btnMap=new Button("编辑地图");
& L0 D7 |8 p3 a$ Q: U        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
1 W1 v+ D+ l  E1 J+ s/ Q public void init() {
& j7 V  k) u  U: K) T! P0 h7 _' b                //初始化函数，先画各种控件
  setLayout(new BorderLayout());
6 D3 q. ~2 P7 p6 l/ E                Panel pan=new Panel();
                add("South",pan);
2 H* Y& X3 I# K% v) A. W                this.add("Center",canvas);
2 V- M4 D1 M( X3 W                pan.add(btnStart);
! ^8 ~. W: c; c                pan.add(btnReset);
3 p, n, U' q$ X                pan.add(btnConfig);
                pan.add(btnMap);
                pan.add(choPDraw);
                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
, O; Y" A7 r2 j, ^: _                choPDraw.addItem("画食物信息素");
                choPDraw.addItem("画窝的信息素");
                choPDraw.select(2);</P>
0 D! g( M- X# @" E" n7 ^<>                //初始化各个数组
  obs_grid=new int [width][height];
- R& }4 i% {$ r& d6 \                phe=new Vector();
* I" d- H' i. J$ M3 c2 {                Pheromone_grid=new int [2][width][height];
                for(int i=0;i&lt;width;i++){
/ C$ W7 K- m! C4 ~   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
% c+ {0 P+ z2 S  e9 v                                for(int k=0;k&lt;2;k++){
$ N4 r2 I5 h8 T. [8 k5 |; Q                                  Pheromone_grid[k][j]=0;
                                }
7 m) R: r. y6 R   }
3 q9 n+ T, V9 V* l- ^' a% f/ ?  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
$ r1 [( |. [3 u( m' }( G' Y: w0 c          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
  }</P>
3 U7 Z) p) q+ \  W3 x<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
0 `$ i5 k3 l' P. g                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
                Maps maps=new Maps();
  g: K; }  {" e/ T7 _. S# K0 H* L                maps.LoadMap(grid,0);
                //初始化地图
                reinit_map(grid);</P>
  u" \4 J: }2 K* c<>                //初始化所有的蚂蚁
' h! M. S, k( z5 a2 q  reinit();
}
        public void reinit_map(int grid[][]){
2 {0 A+ b4 z  ^# r4 q" W. R                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
<>                //先停止程序的运行
# R5 W! Z. u' v* R9 l                running=false;
' c3 W8 W9 l( p. y9 K' }4 _                btnStart.setLabel("开始");</P>
* Q6 o9 e/ U# A' m( N<>
                obsCount=0;
: j! k8 i+ ]4 W0 j* \                EndPts=0;
& y" ]; ~  M$ x) f6 b# n                OriginPts=0;
                obsP=new Point[width*height];
                OriginPt=new Point[100];
% b1 p- h8 p' c" |; w! S                EndPt=new Point[100];</P>
<>                //清空obs_grid和Pheromone两个数组中的值
                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
& Z* L$ ]. [0 _                                  Pheromone_grid[k][j]=0;
$ K! J% S; b+ D; l1 H                                }
   }
  }</P>
$ @  U( J2 M2 ?* D" X<>                //从grid数组中读取信息
, T9 Q; s2 {! ~- b  c% A                for(int i=0;i&lt;width;i++){
( R* F: s) _5 m  _1 c: z/ J  R                  for(int j=0;j&lt;height;j++){
8 j3 @. x; S% G. x( ~8 }                    switch (grid[j]){
                    case 1:
. s; N/ L4 m# o* ]                      //如果grid[][]存的是障碍物
                      obs_grid[j]=obsCount;
% e* {$ k+ S% C0 C                      obsP[obsCount]=new Point(i,j);
. K! e; E; c  D. T; a1 X- v                      obsCount++;
& d: o3 ^+ Q* {8 T                      break;
                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
0 ^" ~$ C0 h1 K! _9 \                      if(OriginPts&lt;100){
                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
+ h$ z" r5 }1 K                      }
( n- Z6 M: ?# @/ h8 H                      break;
                    case 3:
                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
2 V; _/ C- A: q' H9 `                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
                      }
8 ?6 ^2 U& l; [' j3 C                      break;
1 M1 u  ?& @* [: G- `                    }
                  }
' s) N" F9 n( a" y6 j                }
            //如果没有指定窝，则随机的选择一点
" k! k, S8 V) D7 s: Q) f( k4 V            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
                int  j;
/ J& M. G, R& r# Y- A/ X6 k                for(j=0;j&lt;height;j++){
( U* v) p; f: E; O" h4 q: e                  if(obs_grid[j]&lt;0){
, [2 W# I6 z, @                    OriginPt[OriginPts]=new Point(i,j);
                    OriginPts++;
                    break;
                  }
                }
) B( p8 J. p7 O& J* y5 }                if(j&lt;height-1){
% R2 r1 y. Y1 Y, ^2 j                  break;
9 v" R, S8 `+ Z* z) z                }
1 O; L/ X& L1 Y8 N# T' E7 O) {" H5 W3 y              }
# ?8 }$ w, q$ ^; R8 l$ s" h            }
9 y0 s. o, a/ t$ \6 e9 R        }
public void reinit(){
                //重新初始化整个环境</P>
<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
<>
  //清空所有信息素Pheromone数组中的值
# P( S" g$ k5 R, H                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
                                for(int k=0;k&lt;2;k++){
* L: j" p4 F' ^: d+ J8 ~                                  Pheromone_grid[k][j]=0;
, k# R8 O* H% ~. Q8 G2 x                                }
   }
  }</P>
/ r: ~2 j- Z' K<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
6 c! A% E' m$ N7 E1 d" P6 P* K        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
          ants.OriginPt=new Point(OriginPt[index]);
                        ants.init();
" A1 c. n$ F4 P5 q  }</P>
7 p) q+ g$ r; p6 T! e6 M- i<>                //清空信息素向量
) ^, k) f2 @- D2 ^* B) O7 l                phe.removeAllElements();</P>
& A/ c- f3 S/ ~9 B6 ]2 Y6 c<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
3 d1 J; Y7 r& h9 y  for(int i=0;i&lt;EndPts;i++){
5 u6 \0 m, p$ z. U                   for(int x=-FoodR;x&lt;=FoodR;x++){
) z5 T! P& I; T6 c4 j                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
, X# v9 e: x5 F) J                        for(int yy=-y;yy&lt;=y;yy++){
, \2 f- P" y% T" [                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
7 a% R1 ^% O# v+ m* r                    }
7 c3 l2 K' p+ R                }
6 c' P/ n; a" b  r1 W/ s" a& ?9 X                for(int i=0;i&lt;OriginPts;i++){
6 [: R4 E+ v7 E8 s                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
% Z+ Q- i0 I$ \6 b; w1 ?                        for(int yy=-y;yy&lt;=y;yy++){
                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
* Z1 {! ?% V' }4 t                        }
/ d1 d4 v3 [. h* W                    }
2 R6 M  h. D5 g! \1 S+ b9 m6 K                }</P>
# w" [7 C! \0 U  {0 [* G<P>                //重画
  canvas.repaint();</P>
<P>                //让程序开始运行
                //running=true;
3 o3 F, r3 p; F1 h3 M7 s9 g/ p. I }
: C% Q* c! Y; A* k9 M5 k$ R public void paint(Graphics g) {
  canvas.repaint();
}</P>
4 Y! G4 e" D. }4 w7 l# q9 q9 M<P>
public static void main(String[] args) {
    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
    Frame frame;
3 g: ^% `! X/ @    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
7 t9 q4 b& K6 E- }3 Z; E7 u2 _        super.processWindowEvent(e);
: u; u8 \9 f. H5 i% Q, O        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
          System.exit(0);
        }
      }
      public synchronized void setTitle(String title) {
" ^. h1 P) s0 Y        super.setTitle(title);
' n0 l4 ]2 V+ Z0 Q  f+ V        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
+ P5 j. Z2 w# N- I5 V. Y; N      }
. n$ v% a  O# _# U( d/ J    };
% Q2 i3 j$ i$ ~' [4 g% }# t" d    frame.setTitle("Applet Frame");
7 {+ ^  w' r7 x- B    frame.add(applet, BorderLayout.CENTER);
    applet.init();
    applet.start();
  X) u  s2 w" e1 w/ i; E. F    frame.setSize(300,320);
  {9 ^+ G+ c8 p1 j' V% v5 D    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
    frame.setVisible(true);
. J$ P  b+ ^) z. x2 K  }
  public void start()
  //下面三个函数是控制线程的
: Z) n8 @9 k- K8 C: i. L4 q0 r {
- w8 P! G7 K  D; t  if (runner == null)
  {
   runner= new Thread(this);
; Y7 Z9 H: E- B4 g; w+ `4 Y5 m   runner.start();
   //running = true;
  }
3 {! U$ ~7 V. E }</P>
<P> public void stop()
; q1 y+ T. l& }* E. V2 H {
- {2 E3 X1 k" m% Q- E  if (runner!=null)
( z9 V8 |0 j9 g) x- J. L- [# F  {
   runner.stop();
9 i/ A, k% X; N   runner=null;
   running = false;
( Z% i* K1 @7 S% @  }
/ D* ~3 A% L& Z  q/ m+ B$ C }</P>
. ]) f% @; G! @) @* D8 {<P> public void run() {</P>
<P>  int i;
                //线程一直运行下去
' z5 k( _/ ^1 f2 n6 c9 S4 G  while (true) {
          if(running){
       //如果开始动画，就进行canvas的处理
                          canvas.process();
                        }
, z9 w0 w7 m1 V2 s+ P$ a3 c    try { Thread.sleep(delay);}
0 l/ Y# \- H0 E; a7 A& X    catch (InterruptedException e) {
   }
) x! C" o! N/ q( o6 W/ d: H( B  }</P>
<P> }
        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
                //开始编辑地图面板
   running=false;
. ?/ l' s3 _1 w! n- l( ?1 [( z0 u) [                        btnStart.setLabel("开始");
# B+ v; y6 _" o: H, t   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
3 O$ b) _) f  n- t$ W# W& g                        ctl.show();
                        return true;
  }else if(evt.target == btnStart){
                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
4 x: B. b; P9 ?                    if(reset)reinit();
" d; C# [9 }6 K1 D                    btnStart.setLabel("停止");
; V- a/ j- n6 Z" @; h2 G                    reset=false;
                    running=true;
                  }else{
                    btnStart.setLabel("开始");
  W6 D' d- |6 L; L# X                    running=false;
. @7 C9 O) v8 X$ G1 j$ e                  }
                  return true;
7 u1 i" i$ c  i; C; p4 T! `                }else if(evt.target == btnReset){
' h8 h0 W  r0 {                  running=false;
                  int j=0;
" X1 }/ r  \0 O+ J* s* \& M( Z                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
: r% i+ i4 V1 N                  reset=true;
- v* C5 m- k, n9 Y% q                  repaint();
                  btnStart.setLabel("开始");
" R; S  U& P. u& ^+ A5 G                  return true;
+ p# [- T7 f: D2 Y- w  [0 `* m                }else if(evt.target == btnConfig){
                        running=false;
9 ~" N* h+ [( V+ `3 a* x0 T                        btnStart.setLabel("开始");
/ A6 o( A$ t, [     Configer ctl = new Configer(this);
) Y2 @1 ?  y9 Y4 P1 N                 ctl.setSize(300,300);
1 U+ T% W" f# X* C, B3 |                        ctl.show();
% w3 D% u% e( `; I  q                        return true;
1 ?; ?% X, x$ A                }else if(evt.target == choPDraw){
                  //选择画信息素的模式
5 v( v# g: W5 H4 x$ g; I3 `                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
% Q$ I/ w2 @. p8 u* x; v                  return true;
                }
$ d: N' M( c9 |5 ?% [                return false;</P>
, ]9 L' Y  @' ]<P>        }
/**Destroy the applet*/
  public void destroy() {
  //当结束程序的时候，把线程也结束
' w& |5 k- O4 r4 ]3 v    if (runner!=null)
    {
       running = false;
; }* A  O. Z# x! i       runner.stop();
       runner=null;
* K( n. K- A/ `+ Z; a, r  F7 y5 f    }
  }</P>
<P>}
</P>
2 P( u' z2 `* a& \2 w" U! H
8 E, e( w! o0 S* J

<P>package ant;
5 H6 `% n- c, s! v) ]& E' gimport java.awt.*;
" X* f" s. E$ x9 N/ p4 B& o9 u5 V: gimport java.applet.*;
import java.util.Vector;</P>
# s9 J) x6 Q+ j: b. Y<P>public class ant{
# H' P! e7 `- V0 X Point nowPt;//当前点坐标
2 F4 f/ a3 u- d) q7 o/ e$ x int VR;//速度，每次蚂蚁能走动的最大长度
  int id;//标识
  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
int height,width;//世界的尺寸
        int Phe;//每次释放信息素的数值
Antcolony local_colony;//主程序的指针
) X3 r/ b0 l+ `$ \7 F9 L* O0 I3 t, I        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
8 Y7 m7 R, T9 t0 {% M        double Main_direct;//主方向
        Point FoodPt;//记录的食物点，是否找到时候判断用
        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
+ H% x3 U" O, [6 ?        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
2 H  p2 F9 Q, o+ J! x- e) @7 M: A        int Max_Pheromone;//最大能够释放的信息素
  b9 c4 D* E8 n, `' n        int Pheromone_count;//当前还拥有的信息素的总量
$ d0 J  o6 L" ]        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
$ H3 U) M' U/ K  C        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
6 l5 u0 B; C" F8 v        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
& {# V& o; X( _. U4 h  nowPt=new Point(nowpt.x,nowpt.y);
! H* k; ~6 f3 e+ E+ D                OriginPt=new Point(nowpt.x,nowpt.y);
                FoodPt=new Point(nowpt.x,nowpt.y);
7 R; v3 P! t$ q2 u                StartPt=new Point(nowpt);
                AimPt=new Point(nowpt);
                lastPt=nowPt;
  VR=vr;
3 A5 _, n/ I/ z3 X. l8 e  g  id=idd;
- O1 X9 n9 v8 Q: ?. P+ c  color=c;
. z' R; G  M5 y  back_color=Antcolony.BACK_COLOR;
) X. v( L* {) I9 \. C1 _  height=Antcolony.height;
2 L! s2 i8 r( z4 Q( V  width=Antcolony.width;
  local_colony=colony;
# |3 f3 }+ n# E+ _                Phe=200;
                mistake=mist;
6 Z+ O* l6 e6 e  Z                HistoryPoint=new Vector();
! T7 R' w6 w' _5 p: ?7 M                Main_direct=-1;
                FoundTimes=0;
4 E" D4 x/ ~4 I; s: _                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
! c2 d3 o& l2 o7 o                memory=mem;
8 H* J+ s: X3 E8 f- }# D7 n- Z: N                Count_distance=0;
; U! P8 C% Y" {3 |( B' Y                Min_distance=-1;
( A' w5 N. N+ V0 O' q& k. E }
        public void init(){
5 z) G& t, ~, J) C* E          nowPt=new Point(OriginPt);
; v+ l1 h0 {/ o0 ~6 A- r; I& [  E          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
, j- }6 e4 n. |: s4 w* @% r          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
. m+ f/ a& ?/ j0 [9 K          Main_direct=-1;
          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
6 ^4 m/ x3 C) [) O$ c4 F! @          Count_distance=0;
: Y6 z6 q5 j) t) ^5 ^, g" _          Min_distance=-1;
        }
public void Draw(Graphics g) {
) n# Q/ ?2 w! D% p. ?" z          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
6 S. o" q' i2 Y, {. q1 d" }7 n  g.setColor(back_color);
  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
) I' [7 }; \/ Z  g.setColor(color);
% c) G) N/ U4 K; Q  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
- K" ]  E% J" t& W9 } }
6 V  R/ E+ E* S2 y public void Process(){
0 p, d$ l0 }6 P# ]7 C+ S- N* U        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
5 y$ t& F3 ]5 T        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
7 k4 {8 b- E% f4 {9 {  i4 J! t: G        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
7 e) |) a5 W" I        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

4 v! s$ S- X( W* W# y% H<P>        if(Judged==false){
: K$ {5 W  S& C$ ^% T          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
/ ~6 Q# Z: M# `. x# p' j: @          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
% E* z- t  a/ P/ k6 q( {          if(JudgeEnd()){
2 d. C8 b) _( t' n              //判断，如果找到了目标点那么就退出该程序
) s! \- W  H4 @; g& o* s( O              Judged=true;
$ Q, z6 i3 z6 i" R/ O              return;
. R/ m  @  A/ s" M# e) U          }
9 S5 J& t3 C: p* o( N        }
/ L- k2 X: P/ A: T2 P" [# ^& }: b        Judged=false;
        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
8 ~& X" P; I5 U1 t/ Q( ~; b        double direct=SelectDirect();</P>
: @6 F4 t) T  b) ?% w  L<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
: i& t" ]% J& U0 G# C5 D        //direct是方向角，根据方向计算位移
        deltx=(int)(VR*Math.cos(direct));
        delty=(int)(VR*Math.sin(direct));</P>
<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
8 `9 q% g- M; \: D' f( A        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
* u! Z1 ^& p0 V6 N7 l        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
1 R& d* Q2 u: L$ S/ a        int maxphe=here;</P>
) g, x4 K# x2 h) V<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
5 N& |, T( G0 [          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
4 e$ ~1 H9 g+ b          for(int x=-VR;x&lt;=VR;x++){
7 f: y  a' {5 r" O             for(int y=-VR;y&lt;=VR;y++){
1 f* B: Q  q7 T+ o& s                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
. b5 l( ]* z( A* N$ E& `' ~) ]                int yy=(nowPt.y+y+height)%height;</P>
6 o* p' Y/ H4 s. ?, b<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
<P>                  //如果搜索点的信息素比已经找到过的信息素多
8 L) z1 F, \4 Y; l* O: d                  if(maxphe&lt;phe){</P>
<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
                      double ra=Math.random();
& T7 W0 q6 U' a                      if(here==0||ra&gt;mistake){
& ]. W1 A6 f( `" j% N+ k) K3 @                          boolean found=false;
                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
                          int minsize=memory;
5 \$ l0 J" @* z& m                          if(size&lt;memory)minsize=size;
                          for(int i=size-1;i&gt;=size-minsize;i--){
1 \9 f% K; b* w- M. [4 d                             Point pt=(Point)(HistoryPoint.elementAt(i));
                             if(pt.x==xx&amp;&amp;pt.y==yy){
                                found=true;
                                break;
2 G' Y; L  [. e4 P' L                             }
1 N. `8 e& H  e4 x$ }                          }
                          if(!found){
; D# H7 l+ T0 X$ k3 l( r                            //如果没有原地转圈，那么记录信息素。
, ?/ k5 \) q4 @0 G. u                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
6 W! P. U  Z5 |. v7 d                            deltx=x;
                            delty=y;
: n, t( D0 Q" H! d8 T                          }
                      }//end here==0||ra&gt;0.001
) o' S, b* k7 G, {4 u2 f                    }//end maxphe&lt;here
                }//end if x!=0
& p& C5 w+ |4 Q+ o* A            }//end for y
        }//end for x
) C: H; Z1 ^& ^        Point pt;</P>
* W  W9 S, r, f<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
        pt=Evade_obs(deltx,delty);</P>
! m- x0 F% T( n, J' Z  T" V- y<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
6 g" e0 M; Z: [! I7 p( f& F& [          pt=Evade_obs(deltx1,delty1);
        }</P>
  N- N$ y7 e$ B# I" n( t# M* h<P>        //播撒信息素
; u5 i/ O! C( u$ l( s        Scatter();</P>
<P>        //记录走过的距离
' r4 b3 s" R3 u# F" R/ b/ {        Count_distance+=Distance(lastPt,nowPt);</P>
<P>        //改变当前点位置
: ^4 @# {* j; z2 k4 B6 o        lastPt=new Point(nowPt.x,nowPt.y);</P>
9 y+ d6 l7 x& M<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
        if(HistoryPoint.size()&gt;memory){
          HistoryPoint.removeElementAt(0);
        }
! U8 V0 ^" q4 [2 O8 v( {% b, f  m        nowPt=new Point(pt.x,pt.y);
     }</P>
% U% ~& z: h+ m/ T9 ~<P>
+ Q1 {3 w) {/ \& z9 c1 R# Z* l, t        private void Scatter(){
        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
. o$ m/ Y# Z1 J( l            int kind=FoundTimes%2;</P>
# C( Y; V  ?4 V6 a9 @3 S$ j<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
            boolean ofound=false;
+ f6 p* }% V, q) I2 `0 ^2 n            if(Phec!=0){
0 G* ?0 {) D5 v. n. s( b                //如果当前点已经有信息素了
                for(int i=0;i&lt;local_colony.phe.size();i++){
/ i0 A0 \% D5 s                    //在信息素向量中查找该点的信息
; t8 g1 Y8 a  f2 H                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
+ V; O8 U& |/ ~                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
% v! G/ T; u. Q2 r/ y3 Z8 k                        ofound=true;
! T5 Z- z# K" ~7 U6 P                        boolean found=false;
                        if(size&gt;4){
                           for(int j=size-4;j&lt;size-1;j++){
& e1 g1 e( R+ C                              Point pt=(Point)(HistoryPoint.elementAt(j));
                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
* e' i) z0 g. V                                //如果当前点重复了以前走过的路，就不释放
4 D8 d5 z3 n/ G- |% H- f                                found=true;
                                break;
                              }
                            }
                        }
, h3 v3 U; O' p% D+ @1 W9 T  A# [                        if(!found){
                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
6 `: E- W5 {4 O" D' u<P>                             //让还剩下的信息素总量减少
7 j2 ^: d& y8 p                             Pheromone_count-=Phe;
                        }
                        break;
0 ?3 ^/ `0 ^, a                    }
6 D. Z; O1 W3 ]# M( Q# j/ w                }
2 O( O1 d& r( s8 Z' G' h! f1 A2 u              }
          if(Phec==0||!ofound){
3 p/ g- u  h. P- O            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
3 f9 ]& R3 ]# D& k$ ]# Y$ G                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
. t# Q- i4 r( W                ph.Add(Phe);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
                local_colony.phe.addElement(ph);
. `. x$ q- u8 U( {' o. r- _                //让还剩下的信息素总量减少
0 a& {" d4 |$ C1 \- z. f                 Pheromone_count-=Phe;
0 H3 Z0 ^4 K$ s) L5 H6 d! n           }</P>
5 P2 |: |. v' g8 j6 G* s. ^<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
+ y/ Y/ M( s8 `  N+ x1 l6 r) R           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
# r& }: y; g, @: p7 j           Phe=(int)(0.005*Pheromone_count);</P>
& J8 c2 B# H. a- ?<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
        }
2 [3 r# e1 K4 T# o8 Kprivate boolean JudgeEnd(){
5 V5 V7 J0 _/ G  K6 D) R$ {' B1 b  j4 X    //这个函数判断是否已经找到了目标点
    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
3 `0 R+ [/ l/ B" {: l    if(kind==0){
9 j3 h* Q* G! Q. e5 _( ]! p( g        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
' {/ f- I2 t9 H% W- r! |1 h% i        int i;
0 p- ^# e1 v) r# |        for(i=0;i&lt;local_colony.EndPts;i++){
            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
: P8 p& _  O) r; }              //如果找到了食物，就直接移动到食物点
8 H7 ?' H7 t: ~              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
8 k( ]# _( f( A. s  _, Y5 t              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
+ M& b- s* c# u) {5 L3 d3 A                 Min_distance=Count_distance;
              }
/ d: ]4 O7 Q4 {1 U; k; O+ x& `              //清除总距离记录
              Count_distance=0;</P>
! q" w3 q1 m- U! l8 G  z<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
( ?" c( x6 s6 O6 `9 @) I              AimPt=new Point(OriginPt);
              StartPt=new Point(nowPt);
) l" Q' Y7 w) R: U8 m1 {# `) K1 T              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
7 w; O5 U- {+ J# u<P>              //找到了食物就把找到次数+1
1 i# L  R& ^0 J( K, D) n              FoundTimes++;</P>
<P>              //改变主方向为原来方向的镜面反方向
) i! Z. m# b0 d. c0 Q% c              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>              //重新把自己能撒的信息素置为最大值
, P! Y  d* N% E) ^3 k3 D              Pheromone_count=Max_Pheromone;</P>
# \8 m! }2 Z( Z8 n( C/ O7 S6 T<P>              //清空记录的所有点
3 l; j' ?$ g2 _; V              HistoryPoint.removeAllElements();</P>
0 T; D$ R9 j7 ?' d& p# a- k<P>              //返回找到为真
              return true;
% v9 O: w3 ?0 R3 K; X            }
- ]9 P" n4 v3 B/ A        }
: V3 P/ z& g7 X0 b) ?& Q" N      //否则没找到
      return false;
    }
    if(kind==1){
: [3 P, t. f3 i* f" z        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
  ?$ c: E+ M' Q/ v( }        if(Distance(nowPt,AimPt)&lt;=VR){
            lastPt=new Point(nowPt.x,nowPt.y);
& x/ s6 r; `9 b3 G            //如果找到了目标，就直接移动到目标点
* ^% U' F( e0 I2 ~7 [" ?# ~2 R            nowPt.x=AimPt.x;
( ^# A: W3 S0 T7 e6 f' F' v            nowPt.y=AimPt.y;</P>
+ N, m( P# V0 X4 ?( z* q<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
5 w" `  y  c5 p% n0 A/ s1 z1 c              //比较大小，记录较小的距离
/ z1 j9 ]( ^% Z9 X              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
1 I2 V' e# z4 ?+ A                  Min_distance=Count_distance;
2 o! S+ }5 V5 F! }0 u              }
- x/ F# U' F+ L) |( w              //清除总距离记录
7 N" q) v- E  o6 h3 U* f- t; @3 N: S, g1 h              Count_distance=0;
* `! ?$ F: b3 I( w            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
. n3 W$ R3 I) ]* y            StartPt=new Point(OriginPt);</P>
( M4 x, @) i% @7 M; e<P>            //重新置信息素
) v- J3 i5 Y+ U8 V4 t- d- o, ]            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
$ K7 o1 Q# W& |- }, W7 _            HistoryPoint.removeAllElements();</P>
<P>            //主方向反向
3 b! n: F  N& G5 B- J9 o" Z            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
3 R; m/ D$ ?  x<P>            //找到次数+1
            FoundTimes++;
2 U2 ^) z4 d2 u            return true;
6 {4 y# x/ z4 v6 r        }
        return false;
    }
2 s' x3 U! C. d% u0 s    return false;
/ B# w! U- H& w1 `}
( t7 W" G4 Y6 a- F3 @: k        private double SelectDirect(){
                //选择方向，最后选择的方向为主方向加一个随机扰动
$ \/ \4 k8 c, p7 i2 {* r) ^% e                double direct,e=0;
2 C& J, x2 z8 {" K. Z6 W                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
        e=2*Math.PI*Math.random();
                      Main_direct=e;
                }
                //选择主方向角
                direct=Main_direct;</P>
5 Q% ^/ t" u: f7 O. X) o<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
                double re1=Math.random();
) Q  d; d$ x5 [7 b/ N/ R: U                direct+=Math.PI*(re*re-re1*re1)/2;
* M% s' c. C# a- T                if(re&lt;0.02){
                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
1 F, _# Y6 S- S2 `5 \$ l2 ]1 K0 o                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
" G5 q9 t$ q0 J# v2 N* }7 T# H                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
. X6 `( R7 G' t' g7 ~                       Main_direct=GetDirection(pt,nowPt);
                    }
                  }
4 R$ e3 f. ~  B' t: E                }
7 ?. n3 m. R6 l% f               return direct;</P>
0 |  J: E) ~6 F/ j' _7 {<P>        }
* i" y- v, H' T  e  D# q        private Point Evade_obs(int deltx,int delty){
              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
3 I5 O/ h6 {1 F' j( I" [, x              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
% ]! V, c9 X9 \- @; O              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
& T' G# E+ K. F2 x& `              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
' ~% x" o9 F$ t1 x              Point pt=new Point(0,0);
3 A8 K7 J9 d) z% R# b              int x,y;
) \! i9 N% [! y% E+ V; B3 b              int delt=deltx;
6 f" Z, O8 G5 G' U* u% b              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
+ D$ y+ m- I  G7 f- b0 h              if(delt==0)return nowPt;
              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
                  x=(x+width)%width;
0 S2 z& }! k, Y/ m                  y=(y+height)%height;
( }, }/ V3 c( O! P3 a( e7 k( {; b, J                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
, d; H7 X7 o+ @  M% }% f, _4 T6 Q! @<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
2 ^7 {. y. {, M" p0 I* Z, i: n8 A                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
                     double disturb=4*Math.PI*(Math.random()-0.5);
+ g9 e, @2 K. G/ j, D                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
5 c: @1 [/ N. X5 k" p                     break;
                  }
& Q( n2 E. B0 d; A+ O/ q  w                  pt=new Point(x,y);
8 r  p0 I5 P9 N. F& A$ g                }</P>
<P>                //计算得出实际能够到达的目标点
! i$ G8 g( L8 D& R8 H  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
         return new Point(x,y);
        }
        private double GetDirection(Point pt1,Point pt2){
" f- }! o2 _% P        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
        //其中方向角是所有可能的角中使得两点连线距离最短的角。
" r9 o/ |0 H3 Y4 J2 |               double e;
               int deltx1=pt2.x-pt1.x;
4 r; h% Y/ j* m               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
               else deltx2=pt2.x+width-pt1.x;
1 h* S( s0 e' v' E               int delty1=pt2.y-pt1.y;
               int delty2;
' w6 T& X+ z4 [" F               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
. T4 G( L7 `9 {               else delty2=pt2.y+height-pt1.y;
: r% t4 h, R3 F( e8 o, q5 a               int deltx=deltx1,delty=delty1;
  n) a0 [6 C0 i& l               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
               }
$ k8 r7 H; g: t: W+ t# {        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
. Z7 f+ B8 h3 b6 S( k1 m               }
               if(deltx!=0){
4 P6 |1 [( W/ I6 [' b                    e=Math.atan((double)(delty)/(double)(deltx));
% S* y/ j0 Z7 s. p; W( ^                    if(deltx&lt;0){
0 f5 f! s! ^  r2 @2 C                       if(e&lt;0) e=e-Math.PI;
3 a9 ~" y6 G: S5 m/ [7 l5 E: X0 Y                       else e=e+Math.PI;
                    }
                }else{
                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
                }
                e=(e+Math.PI*2)%(2*Math.PI);
$ q  a. A$ r  ]2 E2 c9 V                return e;
1 z* x6 j+ p) Q4 |& O. o        }
        private double Distance(Point pt1,Point pt2){
  {+ f+ {$ ?2 V) }1 Q        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
9 w$ e& b) |/ M2 k- Z6 ]        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
( s* w. o$ f% {. m5 k- ]  `            int dx2;
            int dx,dy;
            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
            else dx2=pt2.x+width-pt1.x;
            int dy1=pt1.y-pt2.y;
, f4 T% I/ \) ~0 B' Q2 F4 y' e            int dy2;
* ?  w' S; n( H: v$ ]: t. \- i4 Q            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
! M, o! u/ [, X' h# j+ C- e            dy2=pt2.y+height-pt1.y;
" O+ ]# Z1 M  w0 j            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
& ?- M/ L2 u9 |- M: j2 i% H            else dx=dx2;
  }& ?+ ~% V7 }  @            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
            else dy=dy2;
            return Math.sqrt(dx*dx+dy*dy);
        }
( O1 z: h/ R8 p    public void clone(ant ant1){
        //把蚂蚁ant1的属性拷贝到本蚂蚁
     nowPt=new Point(ant1.nowPt);
        OriginPt=new Point(ant1.OriginPt);
        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
( J9 G/ Y# {) }; E3 Y; _5 t        AimPt=new Point(ant1.AimPt);
        lastPt=new Point(ant1.lastPt);
5 q( o* {$ t8 c/ s3 V/ _        VR=ant1.VR;
4 L( T# r0 O5 W' |# `; l        id=ant1.id;
1 ]; F$ x3 L, ^3 s( @7 |        color=ant1.color;
  [4 g' Z, Y+ n8 a) T7 a" j        back_color=ant1.back_color;
4 g5 I3 n/ N9 o" E: R/ t$ c        height=ant1.height;
        width=ant1.width;
        local_colony=ant1.local_colony;
        Phe=ant1.Phe;
        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
5 I, L. S" w) q6 ?- X. S% ?        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
6 N* z% \7 P3 R& A' O3 V        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
        memory=ant1.memory;
        Count_distance=ant1.Count_distance;
        Min_distance=ant1.Min_distance;
    }
}</P>

---

欢迎光临 数学建模社区-数学中国 (http://www.madio.net/)

Powered by Discuz! X2.5