基于matplotlib库下animation、pyplot功能进行的一个生态的模拟程序，参考了一些网上可视化的教程和生态模拟的参数。在本程序中由4种东西构成生态系统，草、草食动物、肉食动物、空地，使用了搜索的算法、random函数来模拟动物进食关系，以及动物的捕食动向，最后通过times间隔每秒展示出animation动态图的画面。
 
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np


def addGrass(_num):
    for i in range(_num):
        x = np.random.randint(0, size)
        y = np.random.randint(0, size)
        while grid[x][y] != 0:
            x = np.random.randint(0, size)
            y = np.random.randint(0, size)

        grid[x][y] = 1  # 1代表草


def addGrassEater(_num):
    for i in range(_num):
        x = np.random.randint(0, size)
        y = np.random.randint(0, size)
        while grid[x][y] != 0:
            x = np.random.randint(0, size)
            y = np.random.randint(0, size)

        grid[x][y] = 2  # 2代表食草动物


def addMeatEater(_num):
    for i in range(_num):
        x = np.random.randint(0, size)
        y = np.random.randint(0, size)
        while grid[x][y] != 0 or growAround(x, y, 2) == [-1, -1]:
            x = np.random.randint(0, size)
            y = np.random.randint(0, size)

        grid[x][y] = 3  # 3代表食肉动物


def growAround(_x, _y, _id):
    field = []
    if _x-1 < 0:
        x_begin = 0
    else:
        x_begin = _x-1
    if _y-1 < 0:
        y_begin = 0
    else:
        y_begin = _y-1
    if _x+1 > size-1:
        x_end = size-1
    else:
        x_end = _x+1
    if _y+1 > size-1:
        y_end = size-1
    else:
        y_end = _y+1

    for i in range(x_begin, x_end+1):
        for j in range(y_begin, y_end+1):
            if grid[i][j] == _id or grid[i][j] == _id*10:  # 2代表食草动物，1代表草，0代表空地
                field += [[i, j]]

    if len(field) == 0:  # 没有食物或者空地
        return [-1, -1]
    else:
        count = np.random.randint(0, len(field))
        return field[count]


def fieldUpdate():
    for i in range(size):
        for j in range(size):
            if grid[i][j] == 30:
                grid[i][j] = 3
            elif grid[i][j] == 20:
                grid[i][j] = 2
            elif grid[i][j] == 10:
                grid[i][j] = 1


def data_gen():
    for count in range(times):
        timesText.set_text('times: %d' % (count+1))
        for i in range(size):
            for j in range(size):
                if grid[i][j] == 3:
                    place = growAround(i, j, 2)
                    if place == [-1, -1]:
                        grid[i][j] = 0  # 食肉动物死亡
                    else:
                        grid[i][j] = 0
                        grid[place[0]][place[1]] = 30  # 食肉动物进食并移动
                        growth = growAround(i, j, 0)
                        if growth != [-1, -1]:
                            grid[growth[0]][growth[1]] = 30  # 食肉动物繁殖

                if grid[i][j] == 2:
                    place = growAround(i, j, 1)
                    if place == [-1, -1]:
                        grid[i][j] = 0  # 食草动物死亡
                    else:
                        grid[i][j] = 0
                        grid[place[0]][place[1]] = 20  # 食草动物进食并移动
                        growth = growAround(i, j, 0)
                        if growth != [-1, -1]:
                            grid[growth[0]][growth[1]] = 20  # 食草动物繁殖

                elif grid[i][j] == 1:
                    growth = growAround(i, j, 0)
                    if growth != [-1, -1]:
                        grid[growth[0]][growth[1]] = 10  # 草生长

        fieldUpdate()
       
        yield grid


def update(_data):
    ax.imshow(_data, interpolation='nearest', cmap='Set3', norm=norm)
    return ax

times = 100  # 迭代次数
size = 40
grid = np.zeros((size, size))  # 0代表空地
addGrass(1200)
addGrassEater(150)
addMeatEater(30)

fig = plt.figure()
ax = plt.subplot(111)
norm = matplotlib.colors.Normalize(vmin=0, vmax=3)  # 固定数值对应的颜色映射
gci = ax.imshow(grid, interpolation='nearest', cmap='Set3', norm=norm)
ax.set_xticks([])
ax.set_yticks([])
cbar = plt.colorbar(gci)
cbar.set_ticks(np.linspace(0, 3, 4))
cbar.set_ticklabels(('Space', 'Grass', 'GrassEater', 'MeatEater'))
timesText = plt.text(-2, -2, 'times: 0') 
ani = animation.FuncAnimation(fig, update, data_gen, interval=1000, repeat=False)

plt.show()
 
 

 
Processing 模拟生态系统
 
博文简介
生物知识
生态系统
   
实现内容
效果展示
操作说明
相关类
技术讲解
遗传
自治智能体
群集行为
个体行为
   
   
问题与思考
参考
其他作品推荐
布料模拟
融入动画技术的交互应用
《Magic Network》：一个小孩都能玩的神经网络交互系统
  
 

 
博文简介
 
使用Processing实现了简单的池塘生态系统。
 主要是鱼——水蚤——水草三类生物的行为。
 关键技术是遗传算法和自治智能体
 
生物知识
 
生态系统
 
生态系统指在自然界的一定的空间内，生物与环境构成的统一整体，在这个统一整体中，生物与环境之间相互影响、相互制约，并在一定时期内处于相对稳定的动态平衡状态。
 
组成成分：非生物的物质和能量、生产者、消费者、分解者。
 
这里模拟了简单的池塘生态系统。忽略掉非生物的物质和能量，还有分解者。只有 生产者–水草、低级消费者–水蚤（以水草为食）、高级消费者–鱼（以水蚤为食）
 
核心规则：
 1、·能量传递的过程中逐级递减，传递率为10%~20%
 这点问题不大，简单来说就是 鱼：水蚤：水草 =100：10：1，当然实际上没有这么简单，实现的过程中没有严格按照这点，大概就是注意鱼的数量少于水蚤少于水草，并且鱼的寿命大于水蚤大于水草，生命值也不同。
 2、生物进化
 这里用到了遗传算法，实现这点的方法是寿命，生物活得越久繁殖概率越大，DNA也就会传递下去
 3、动态平衡
 生态系统通常具有自我调节能力，可以实现动态平衡。
 
生物进化和动态平衡在实现的过程中都出现了问题，比我一开始想的出入很大，在下文 问题与思考 中详细阐述。
 
实现内容
 
DNA：
 寿命 （有最大最小限制）
 速度 （进化需有一定随机性 、突变性）
 大小
 
交叉
 复制
 变异
 
水草：
 生命值（被吃会变透明）
 寿命
 大小（与寿命相关）
 速度
 
死亡
 无性繁殖
 种子扩散
 有微弱的移动能力
 
水蚤（指低级消费者）：
 寿命（性成熟）
 性别
 大小
 速度
 
躲避行为（躲鱼）
 寻偶
 群集行为（主要是对齐）
 吸收养分（吃植物）
 有性繁殖
 
鱼（指高级消费者）： 
 寿命（性成熟）
 性别
 大小
 速度
 性别
 大小
 
捕食（追水蚤）
 寻偶
 群集行为（主要是分离）
 吸收养分（吃虾）
 有性繁殖
 
效果展示
 
完整视频：https://www.bilibili.com/video/av50958125
 
 
操作说明
 
可以通过单击鼠标左键、右键、滑轮添加鱼、水蚤、水草，或单击左上角得“-”号减少
 拖拽可以持续生成（后期生物过多，单击生成减少太慢）
 通过交互人为调节生态平衡。
 
相关类
 
类间关系如图
 
 
下面是各类的域和方法，具体实现和全部代码见 https://github.com/sssal/EcoSystem
 
主类
 
World world;

Boolean isOpenIntroduce;
void setup() {
  size(800, 600);
  frameRate(60);

  world = new World(100, 20, 0);
  textFont(createFont("KaiTi-48.vlw", 48));
  isOpenIntroduce = true;
}

void draw() {
  background(200);

  world.update();

  textSize(15);
  fill(50);
  text("Plants:" + (int)world.getPlantNum(), 20, 20);
  text("Fishes:" + (int)world.getFishNum(), 20, 40);
  text("Fleas:" + (int)world.getFleaNum(), 20, 60);
  rect(100, 7, 20, 12);
  rect(100, 27, 20, 12);
  rect(100, 47, 20, 12);
  fill(250);
  rect(105, 12, 10, 3);
  rect(105, 32, 10, 3);
  rect(105, 52, 10, 3);

  //说明界面
  if (isOpenIntroduce) {
    fill(0, 200);
    rect(width/4, height/4, width/2, height/2, 20);
    textSize(30);
    fill(250);
    text("说明", width/2-50, height/4+40);
    textSize(20);
    text("按 “ i ” 退出/显示说明界面", width/4+20, height/4+70);
    text("左上角表示示植物、水蚤、鱼数量", width/4+20, height/4+100);
    text("鼠标单击左键生成鱼，右键水蚤，中键植物", width/4+20, height/4+130);
    text("鼠标拖拽持续生成",width/4+20,height/4+160);
    text("鼠标单击左上角“-”减少",width/4+20,height/4+190);
    text("鼠标在左上角“-”处拖拽持续减少",width/4+20,height/4+220);
}
}

void mouseDragged() {
  //print(0);
  if (mouseX>100&&mouseX<120&&mouseY>7&&mouseY<19) {
    world.reducePlant();
  } else if (mouseX>100&&mouseX<120&&mouseY>27&&mouseY<39) {
    world.reduceFish();
  } else if (mouseX>100&&mouseX<120&&mouseY>47&&mouseY<59) {
    world.reduceFlea();
  } else {
    if (mouseButton == LEFT) {
      print(1);
      world.addFish(new PVector(mouseX, mouseY));
    } else if (mouseButton == RIGHT) {
      world.addFlea(new PVector(mouseX, mouseY));
    } else if (mouseButton == CENTER) {
      world.addPlant(new PVector(mouseX, mouseY));
    }
  }
}

void mouseClicked() {
  //print(0);
  if (mouseX>100&&mouseX<120&&mouseY>7&&mouseY<19) {
    world.reducePlant();
  } else if (mouseX>100&&mouseX<120&&mouseY>27&&mouseY<39) {
    world.reduceFish();
  } else if (mouseX>100&&mouseX<120&&mouseY>47&&mouseY<59) {
    world.reduceFlea();
  } else {
    if (mouseButton == LEFT) {
      print(1);
      world.addFish(new PVector(mouseX, mouseY));
    } else if (mouseButton == RIGHT) {
      world.addFlea(new PVector(mouseX, mouseY));
    } else if (mouseButton == CENTER) {
      world.addPlant(new PVector(mouseX, mouseY));
    }
  }
}

void keyPressed() {
  if (key == 'i') {
    if (isOpenIntroduce) {
      isOpenIntroduce = false;
    } else {
      isOpenIntroduce = true;
    }
  }
}
 
class World {
  ArrayList<Flea> fleas;
  ArrayList<Plant> plants;
  ArrayList<Fish> fishes;

  World(int plantsNum, int fleasNum, int fishNum) 
  void update() 
  float getFishNum() 
  float getFleaNum()
  float getPlantNum() 
  void addFish(PVector pvector) 
  void addFlea(PVector pvector)
  void addPlant(PVector pvector) 
  void reduceFish() 
  void reducePlant()
  void reduceFlea() 
}
 
class Creature {
  //生物类 所有生物的父类
  PVector position;  //位置
  PVector acceleration; //加速度
  PVector velocity;  //速度

  float lifetime;     //寿命 
  float maxspeed;     //速度
  float maxforce;    //转向力
  float size;         //大小
  float r;            //画图大小

  float maxLifetime; //用来保存生物的最大生命和尺寸
  float maxSize;     
  float health;      //生命值
  float maxHealth;

  DNA dna;          
  DNA fatherDNA;

  //设置不同行为的权重
  float separateWeight;
  float cohesionWeight;
  float alignWeight;

  float breedProbability; //繁殖概率
  float matingProbability; //交配概率

  float xoff;
  float yoff;  //控制随机移动速度

  float periphery = PI/2; //视野角度

  Boolean gender;  //性别
  Boolean isRut;   //是否处于发情期
  Boolean isPregnancy; //怀孕

  color col;      //颜色

  Creature(PVector pos, DNA initDNA)
  //更新
  void update()
  //移动
  void move() 
  //画图
  void display() 
  //添加力改变加速度
  void applyForce(PVector force)
  //三种群集规则
  //分离  避免碰撞
  //对齐  转向力与邻居一致
  //聚集  朝邻居中心转向 （留在群体内）
  void flock(ArrayList<? extends Creature> Creatures) 
  //寻找
  PVector seek(PVector target) 
  // Cohesion 聚集行为
  PVector cohesion (ArrayList<? extends Creature> creatures) 
  //分离行为
  PVector separate (ArrayList<? extends Creature> creatures) 
  //对齐行为
  PVector align (ArrayList<? extends Creature> creatures)  
  //设置发情期
  void rut()
  //寻偶
  PVector mating(ArrayList<? extends Creature> creatures)
  //觅食
  PVector foraging(ArrayList<? extends Creature> creatures)
  //繁殖
  public Creature  breed() 
  // 避免超出画板范围
  void borders()
  //判断死亡
  boolean dead()
}
 
class Plant extends Creature {
  //水草类
  Plant(PVector pos, DNA initDNA)
  @Override
    void display() 
  @Override
    Plant breed()
  //移动
  @Override
    void move()
  //判断死亡
  @Override
    boolean dead()
 
class Flea extends Creature {
  //水蚤类
  Flea(PVector pos, DNA initDNA)
  //更新
  @Override
    void update() 
  @Override
    void display()
  @Override //加入寻偶行为
    void flock(ArrayList<? extends Creature> Creatures)
  //躲避动作
  void moveElude(ArrayList<Fish> fishes)
  //躲避
  PVector elude(ArrayList<Fish> fishes)
  @Override //有性繁殖
    Flea breed()
  //移动
  @Override
    void move()
  //对齐行为
  @Override  //添加视野角度
    PVector align (ArrayList<? extends Creature> creatures)
  //吃水草
  void eat(ArrayList<Plant> plants)
  //判断死亡
  @Override
    boolean dead()
 
class Fish extends Creature {
  //鱼类
  Fish(PVector pos, DNA initDNA)
  //更新
  @Override
    void update()
  @Override
    void display()
  @Override   //有性繁殖
    Fish breed()
  @Override //加入寻偶行为
    void flock(ArrayList<? extends Creature> Creatures)
  //捕食运动
  void moveForaging(ArrayList<Flea> fleas)
  //移动
  @Override
    void move() 
  //吃水蚤
  void eat(ArrayList<Flea> fleas)
  //判断死亡
  @Override
    boolean dead()
 
class DNA {
  private HashMap<String, Float> genes=new HashMap<String,Float>();
  DNA()
  DNA(HashMap newgenes)
  //复制
  public DNA dnaCopy()
  //交叉
  public DNA dnaCross(DNA fatherDNA)
  //变异
  public void mutate(float m)
 
技术讲解
 
向量、力之类的比较基础，这里主要说一下遗传和自治智能体。
 
遗传
 
这部分的代码比较简单。只需要把遗传相关的属性和方法实现就可以了。
 在DNA类中，使用 HashMap<String, Float> 用作储存基因型，键（String）保存基因型的名字，值（FLoat）保存基因间的差别，在Creature类中实例化DNA类并通过值来实现表现型。
 
之后事基因的复制、交叉和变异。
 复制主要用在无性繁殖，直接复制DNA就可以了
 
  //复制
  public DNA dnaCopy() {
    HashMap<String, Float> childGenes = (HashMap<String,Float>)genes.clone();
    
    return new DNA(childGenes);
  }
 
交叉则是有性繁殖，父亲把DNA传递给母亲，然后生成孩子的DNA
 
  //交叉
  public DNA dnaCross(DNA fatherDNA){
    HashMap<String, Float> childGenes = (HashMap<String,Float>)genes.clone();
    HashMap<String, Float> fatherGenes = fatherDNA.genes;
    float lifetime = (fatherGenes.get("lifetime") + genes.get("lifetime"))/2;
    childGenes.put("lifetime",lifetime);
    float speed = (fatherGenes.get("speed") + genes.get("speed"))/2;
    childGenes.put("speed",speed);
    float size = (fatherGenes.get("size") + genes.get("size"))/2;
    childGenes.put("size",size);
    
    return new DNA(childGenes);
  }
 
变异在有性繁殖和无性繁殖中都会出现
 
  //变异
  public void mutate(float m) {
    for (String key : genes.keySet()) {
      if (random(1)<m) {
        genes.put(key, random(0, 1));
      }
    }
  }
 
自治智能体
 
这部分是代码的核心，控制生物的行为。
 生物的行为可以分成两类，一类是群集行为，一类是个体行为。
 运动会受到不同权重，生物的视野和角度影响。
 
群集行为
 
群集行为包括聚集，分离，对齐。
 水蚤的对齐行为权重更大，会与视野内的水蚤速度保持一致。
 统计视野内其他水蚤的速度均值，处理后作为加速度。
 
  //对齐行为
  @Override  //添加视野角度
    PVector align (ArrayList<? extends Creature> creatures) {
    float neighbordist = size * 2;
    PVector sum = new PVector(0, 0);
    int count = 0;
    for (Creature other : creatures) {
      //从一个生物到另一个生物的向量
      PVector comparison = PVector.sub(other.position, position);
      //距离
      float d = PVector.dist(position, other.position);
      //角度
      float  diff = PVector.angleBetween(comparison, velocity);
      if ((diff < periphery) && (d > 0) && (d < neighbordist)) {
        sum.add(other.velocity);
        count++;
      }
    }
    if (count > 0) {
      sum.div((float)count);
      sum.normalize();
      sum.mult(maxspeed);
      PVector steer = PVector.sub(sum, velocity);
      steer.limit(maxforce);
      return steer;
    } else {
      return new PVector(0, 0);
    }
  }
 
聚集则是计算视野内其他生物的位置的均值，生成从当前位置指向均值的向量处理后用作加速度
 
  // Cohesion 聚集行为
  PVector cohesion (ArrayList<? extends Creature> creatures) {
    float neighbordist = r * 5; //视野  ？？？？
    PVector sum = new PVector(0, 0);   // Start with empty vector to accumulate all positions
    int count = 0;
    for (Creature other : creatures) {
      float d = PVector.dist(position, other.position);
      if ((d > 0) && (d < neighbordist)) {
        sum.add(other.position); // 将其他对象位置相加
        count++;
      }
    }
    if (count > 0) {
      sum.div(count);
      return seek(sum);  //寻找邻居的平均坐标
    } else {
      return new PVector(0, 0);
    }
  }
 
分离统计远离其他生物的向量均值，可以用于避免生物间距离过近重叠。
 
  //分离行为
  PVector separate (ArrayList<? extends Creature> creatures) {
    float desiredseparation = r*1.5; //分离视野
    PVector steer = new PVector(0, 0, 0);
    int count = 0;
    // For every boid in the system, check if it's too close
    for (Creature other : creatures) {
      float d = PVector.dist(position, other.position);
      // If the distance is greater than 0 and less than an arbitrary amount (0 when you are yourself)
      if ((d > 0) && (d < desiredseparation)) {
        // Calculate vector pointing away from neighbor
        PVector diff = PVector.sub(position, other.position);
        diff.normalize();
        diff.div(d);        // Weight by distance
        steer.add(diff);
        count++;            // Keep track of how many
      }
    }
    // Average -- divide by how many
    if (count > 0) {
      steer.div((float)count);
    }

    // As long as the vector is greater than 0
    if (steer.mag() > 0) {
      // Implement Reynolds: Steering = Desired - Velocity
      steer.normalize();
      steer.mult(maxspeed);
      steer.sub(velocity);
      steer.limit(maxforce);
    }
    return steer;
  }
 
个体行为
 
个体的行为是求偶、觅食、躲避
 
当个体处于发情期会寻找视野内处于发情期的异性，找到后传递DNA，并结束发情期状态
 
  //寻偶
  PVector mating(ArrayList<? extends Creature> creatures) {
    float neighbordist = r * 15;
    if (isRut) {
      for (Creature other : creatures) {
        if (other.isRut && gender != other.gender) {
          //都处于发情期且性别不同
          //PVector comparison = PVector.sub(other.position, position);
          //距离
          float d = PVector.dist(position, other.position);
          //角度
          //float  diff = PVector.angleBetween(comparison, velocity);
          if ( (d < neighbordist) && (d>r)) {
            return seek(other.position);
          } else if (d<r) { //当两者足够靠近
            //print(3);
            isRut = false;
            other.isRut = false;
            if (gender) {
              col = color(255, 0, 0);
              other.col = color(0, 255, 0);

              isPregnancy = true;
              fatherDNA = other.dna;
            } else {
              col = color(0, 255, 0);
              other.col = color(255, 0, 0);

              other.isPregnancy = true;
              other.fatherDNA = dna;
            }
          }
        }
      }
    }
    return new PVector(0, 0);
  }
 
觅食是鱼的行为，主动寻找水蚤
 
  //觅食
  PVector foraging(ArrayList<? extends Creature> creatures) {
    float neighbordist = r * 10;
    for (Creature c:creatures) {
      //从一个生物到另一个生物的向量
      PVector comparison = PVector.sub(c.position, position);
      //距离
      float d = PVector.dist(position, c.position);
      //角度
      float  diff = PVector.angleBetween(comparison, velocity);
      if ((diff < periphery) && (d < neighbordist)) {
        return seek(c.position);
      }
    }
    return new PVector(0, 0);
  }
 
躲避与觅食相反，水蚤主动躲避鱼
 
  //躲避
  PVector elude(ArrayList<Fish> fishes) {
    float neighbordist = r * 10;
    for (Fish f:fishes) {
      //从一个生物到另一个生物的向量
      PVector comparison = PVector.sub(f.position, position);
      //距离
      float d = PVector.dist(position, f.position);
      //角度
      float  diff = PVector.angleBetween(comparison, velocity);
      if ((diff < periphery) && (d < neighbordist)) {
        PVector result = seek(f.position);
        result = new PVector(-result.x, -result.y);
        return result;
      }
    }
    return new PVector(0, 0);
  }
 
问题与思考
 
1、遗传
 遗传算法是计算数学中用于解决最佳化的搜索算法，曾经使用过用来计算函数的最大值，这里考虑把生物的寿命作为适应度，活得越长适应度越大，这样迭代一段时间后就能够得到寿命最长也就是最适应环境的个体，但在尝试的过程中发现这样太理想化了。
 一开始想要把各项参数都放在DNA中，例如不同行为的权重，繁殖率等，但是发现变量太多，效果不好。
 在系统中只有水蚤和水草时，出现过一种情况是水蚤越来越大，但速度却越来越慢，我猜测因为没有给水蚤添加觅食行为，所以走得慢反而更容易生存，越大觅食范围越大，并且水草不会被直接吃掉，生存概率也更高。但是这种情况我后来并没有复现出来。
 这里放了一种能够体现遗传进化的情况：
 初始为水草：100 水蚤：20 无鱼
 
 一段时间后的情况：
 
 发现水蚤在往大的方向进化，速度并没有越来越慢。
 
这时候我意识到 适应度 的问题，我希望的适应度是寿命，但实际上想要让水蚤因为各项属性影响寿命是很困难的事，我只把参数修改一点点就可能导致生物灭绝或者过度繁殖，所以寿命的随机性其实挺高的。而真正的适应度其实是交配的概率，吃得多活得长，交配的概率高，但影响交配的概率最大的其实是体积，越大越可能和异性接触并交配。
 
2、动态平衡
 正常的生态系统是具有自我调节的能力的，就像狼-兔-草模型中，兔子多了，狼也会多，草减少，这样兔子就会减少，一开始我也是想让鱼-水蚤-水草达到平衡状态，在只有水蚤-水草时还行，加入鱼后我发现这是不可能的，不添加外在条件时不可能的。
 
自然界中其实还存在一些规律，实际上当一种生物增多时，首先受影响的是它的下级，生态系统的调节是具有滞后性的，就像兔子多了，首先是草大量减少，然后才是狼多，需要一定的时间跨度，才能恢复平衡。但在我模拟的生态系统中，当存在鱼-水蚤-水草时几乎无法调节平衡，会持续地往极端发展，并最终全部灭绝。
 
当然这应该有我对生物的模拟不够真实的原因，并且环境太小，没有足够的时间和空间让模拟生态系统运行下去。
 
参考
 
参考案例：https://www.openprocessing.org/sketch/687983
 参考书籍：《The nature of code》/《代码本色》
 
其他作品推荐
 
布料模拟
 
布料模拟
 
 这个作品一下子就吸引了我，很简洁又真实，确实有布料运动的感觉，这个技术的实现让我想到曾经制作的愤怒的小鸟的弹弓。
 布料的整体运动取决于部分的运动，每一个局部运动逻辑是相似的，但整体表现出来的效果又很棒。
 
融入动画技术的交互应用
 
博文地址
 
 一开始实现的跳一跳看起来就很不错，运动、交互的效果看起来很舒服。后边还看到一些有趣的效果，processing实现的融入动画的漫画场景，很好看。最后还分享了一些动画，特别是这个水生物的自然形态模拟，很喜欢，我自己做的生态系统看上去特别丑，早点看到这个例子，或许能让我的作品更具艺术性。
 
《Magic Network》：一个小孩都能玩的神经网络交互系统
 
Magic Netwo
 
 界面画风很符合主题，在学神经网络、人工智能的时候就经常感觉很抽象，很多东西的中间过程难以理解，这个作品非常好，即便是没有学过相关知识的人也可以操作，帮助理解神经网络。

Android开发学习
 
 

 
 

   
Android开发学习
     
什么是Android开发？
Android开发用到的工具有哪些？
Android开发用到的知识有哪些？
Android开发学习路线
Android开发学习资源
 
 
 
 
 
什么是Android开发？
 
    Android开发是指Android平台应用上的制作，是一项包括需求捕捉，需求分析，设计，实现和测试的系统工程。Android开发通常采用开发工具进行开发。 
 * 认识Android系统 
     Android是一种基于Linux的自由及开放源代码的操作系统，主要使用于移动设备，如智能手机和平板电脑，由Google公司和开放手机联盟领导及开发。 
     在这几年的发展过程中，Google公司为Android建立了一个完整的生态系统。同时，手机厂商、开发者、用户之间相互依存，共同推进着Android的蓬勃发展。 
     Android系统架构可以分为Linux内核层、系统运行库层、应用框架层、应用层；Android系统四大组件为别是活动（Activity）、服务（Service）、广播接收器（Broadcast Rsceiver）和内容提供器（Content Provider）。 
 
 
    Google公司有个传统，就是每年都会举办一次Google I/O 大会，且一般在大会上推出新的Android版本。迄今，Google已经发行了17个版本（包括测试版本），目前最新的版本是Android Oreo（Android 8.0）。
 
 
Android开发用到的工具有哪些？
 
    进行Android开发的工具主要有两种一是Eclipse+ADT+JDK+SDK，一是基于IntelliJ IDEA的Android Studio+SDK+JDK+Genymotion。 
     目前，Android Studio是进行安卓开发的主流工具，它与Eclipse相比主要有以下优势：1.比Eclipse漂亮；2.比Eclipse速度快；3.提示，补全更加智能，更加人性化；4.整合了Gradle构建工具；5.支持Google Cloud Platform；6.强大的UI编辑器；7.更完善的插件系统；8.完美的整合版本控制软件；9.Android Studio是Google推出的。
 
 
Android开发用到的知识有哪些？
 
Linux
 
    Android是基于Linux内核的，编译Android源码也必须在Linux上进行，所以开发者应熟练使用Linux的命令行，能够对Linux系统上的文件进行管理，对Linux进行网络配置、进程管理等。 
 
 * 编程语言
 
     在Kotlin 语言出现之前，几乎所有的安卓应用程序都是使用Java语言编写的。但在2017年5月Google大会上，Google宣布Kotlin 成为安卓的官方语言后，经过快一年的发展，使用Kotlin 的开发者中5%增长到了15%，并且还在呈现上升趋势。 
     无论是Java,还是Kotlin,我们Android开发者至少需要精通一门，当然，当熟练使用一门语言之后，再去更改转向另一门语言的这个过程是十分困难的。 
 Java与Kotlin的创建类的简单代码示例： 
 Java
 

class Person{
        String name;
        int age;
}

 
    Kotlin
 

class Person{
    var name: String? = ""
    var age: Int = 0
}

 
 
Android开发学习路线
 
    Android基础阶段：平台架构特性(JAVA/C) ，Market应用程序组件， 环境搭建与部署、打包与发布， AVD/DDMS/AAPT 调试与测试 ，相关资源访问，资源制作， Activity/Service/Broadcast Receiver/Content Provider/原理(生命周期)及深层实现。
 
    Android进阶初级：组件（Widget），菜单（Menu），布局（Layout）， 详解 Xml，解析(Pull/Dom/Sax)/JNI ，解析SQL数据库原理, SQLite /SharedPreferences/File详解 ，多媒体Audio/Video/Camera 详解。
 
    Android进阶高级：蓝牙/WIFI SMS/MMS 应用实现 ，深层次解析GPS原理,实现LocationManager/LocationProvider ，进行定位、跟踪、查找、趋近警告以及Geocoder正逆向编解码等技术细节， 2D图形库(Graphics/View)详解 ，SDCARD/传感器/手势 应用实现。
 
 
Android开发学习资源
 
相关书目
相关网站
视频教学
《第一行代码》
Linux公社
网易云课堂
《疯狂android讲义》
CSDN
慕课
《Head First Java》
Android吧
《精通Android》
GitHub

欢迎来到Arduino的世界，本文主要介绍Arduino的优势，开发所涉及的硬件分类，开发语言及开发环境的下载。可登陆Arduino官网学习了解更多Arduino信息。
 
什么是Arduino
 
Arduino 是一款便捷灵活、方便上手的开源电子原型平台，包含硬件（各种型号的arduino板）和软件（arduino IDE)，她适用于艺术家、设计师、爱好者和对于“互动”有兴趣的朋友们。
 
Arduino能通过各种各样的传感器来感知环境，通过控制灯光、马达和其他的装置来反馈、影响环境。板子上的微控制器可以通过Arduino的编程语言来编写程序，编译成二进制文件，烧录进微控制器。
 
对Arduino的编程是利用 Arduino编程语言 (基于 Wiring)和Arduino开发环境(based on Processing)来实现的。基于Arduino的项目，可以只包含Arduino，也可以包含Arduino和其他一些在PC上运行的软件，他们之间进行通信 (比如 Flash, Processing, MaxMSP)来实现。
 
你可以自己动手制作，也可以购买成品套装。Arduino所使用到的软件都可以免费下载。硬件参考设计 (CAD 文件)也是遵循availableopen-source协议, 你可以非常自由地根据要求去修改他们。
 
Arduino的优势
 
目前市场上还有许多其他的单片机和单片机平台，例如51单片机、STM32单片机等。但他们对于普通开发者来说门槛相对较高，需要有一定编程和硬件相关基础，内部寄存器较为繁杂，主流开发环境Keil配置相对麻烦，特别是对于STM32的开发，即使使用官方库也少不了环境配置，还有就是开发环境是收费的。
 
Arduino不但简化了使用单片机工作的流程，同时还为教师、学生以及兴趣爱好者提供了一些其他系统不具备的优势:
 
便宜。相比于其他单片机平台而言，Arduino生态的各种开发板性价比相对较高。
跨平台。Arduino软件（IDE）能在Windows、Mac OS X和Linux操作系统中运行，而大多数其他单片机系统仅限于在Windows操作系统中运行。
开发环境简单。Arduino的编程环境易于初学者使用，同时对高级用户来讲也足够灵活，其安装和操作都非常简单。
开源可扩展。Arduino软件硬件都是开源的，开发者可以对软件库进行扩展，也可以下载到千千万万的软件库来实现自己的功能。Arduino允许开发者对硬件电路进行修改和扩展来满足不同的需求。
 
Arduino开发板类型
 
Arduino生态包括多种开发板、模块、扩展板、工具和配件。官方将其大致分为五类：入门级、网络版、物联网版、教育版、可穿戴版。具体可从官网查看Arduino开发板类型。
 
 
其中入门级开发板易于使用。建议初学者使用入门级如Arduino UNO R3。
 
 
Arduino开发语言
 
Arduino使用C/C++编写程序，虽然C++兼容C语言，但这是两种语言，C语言是一种面向过程的编程语言，C++是一种面向对象的编程语言。早期的Arduino核心库使用C语言编写，后来引进了面向对象的思想，目前最新的Arduino核心库采用C与C++混合编写而成。
 
通常我们说的Arduino语言，是指Arduino核心库文件提供的各种应用程序编程接口（Application Programming Interface，简称API）的集合。这些API是对更底层的单片机支持库进行二次封装所形成的。例如，使用AVR单片机的Arduino的核心库是对AVR-Libc（基于GCC的AVR支持库）的二次封装。
 
传统开发方式中，需要通过配置多个寄存器来实现相应功能，而在Arduino中，繁杂的寄存器被封装成简单的API，能进行直观控制，增强程序的可读性的同时也提高了开发效率。
 
Arduino开发环境
 
Arduino开发环境IDE可从官网进行下载，支持Windows、Mac OS X、Linux不同平台，对应PC平台进行下载。IDE下载地址
 当前最新版本为1.8.5。我的电脑为Windows系统，Windows版本有三种下载方式，选择一种下载即可。
 
 
关于IDE软件的介绍将在下一节中详细介绍。
 
 
 
更多内容，欢迎关注我的公众号。 微信扫一扫下方二维码即可关注：