Simulación de vida de partículas

el

 

Simulación de vida de partículas

Un programa simple para simular la Vida Artificial primitiva utilizando reglas simples de atracción o repulsión entre partículas similares a átomos, produciendo patrones complejos de auto-organización similares a la vida. Excluyendo los elementos de la GUI, el código es menor que una página. El video tutorial y el tutorial están disponibles a continuación.



Demostración en línea (versión JavaScript):

Haga clic aquí para una demostración en vivo (JavaScript):

Algunos patrones interesantes para reproducir:

No es necesario ser exacto con los parámetros para reproducir estos patrones. La mejor manera de obtener patrones interesantes es probar primero exploraciones de parámetros aleatorios, una vez que encuentre un patrón interesante, intente ajustarlo gradualmente. Para evitar atascarse en un máximo local, puede hacer algunos saltos ocasionales de grandes parámetros. De esta manera, seguirán apareciendo patrones interesantes y diferentes.



Utilizar:

Descargue este repositorio. Descomprima el archivo, luego vaya a la carpeta /particle_life/bin/ y haga clic en particle_life.exe

Código:

El código fuente está disponible en C++, JavaScript y Python. Vea este video de YouTube para ver un tutorial tutorial: https://youtu.be/0Kx4Y9TVMGg

Si desea contribuir al programa C++, el algoritmo central son las primeras 100 líneas de código en: "/particle_life/src/ofApp.cpp". El resto son componentes de GUI y controles de representación que proporcionan la biblioteca openFrameworks, una biblioteca de representación de imágenes de código abierto y fácil de usar.

Para empezar, descargue este repositorio y luego descargue la biblioteca openFrameworks desde aquí: https://openframeworks.cc/. Utilice projectGenerator de openFramework e importe la carpeta /particle_life/ al proyecto.

Alternativamente, genere un nuevo proyecto openFramework y agregue ofxGui. Una vez generados los archivos del proyecto, reemplace la carpeta /src/ por la que se proporciona aquí.

Ahora puede compilar el código de C++ en su máquina.

Otros puertos:

El código JavaScript es tan simple como esto:

Además, mire el archivo de particle_life.html para obtener una versión más optimizada, gracias a aquellos que han contribuido.

<canvas id="life" width="500" height="500"></canvas>
<script>
  //Hunar Ahmad @ brainxyz
  m = document.getElementById("life").getContext("2d");
  draw = (x, y, c, s) => {
    m.fillStyle = c;
    m.fillRect(x, y, s, s);
  };
  atoms = [];
  atom = (x, y, c) => {
    return { x: x, y: y, vx: 0, vy: 0, color: c };
  };
  random = () => {
    return Math.random() * 400 + 50;
  };
  create = (number, color) => {
    group = [];
    for (let i = 0; i < number; i++) {
      group.push(atom(random(), random(), color));
      atoms.push(group[i]);
    }
    return group;
  };
  rule = (atoms1, atoms2, g) => {
    for (let i = 0; i < atoms1.length; i++) {
      fx = 0;
      fy = 0;
      for (let j = 0; j < atoms2.length; j++) {
        a = atoms1[i];
        b = atoms2[j];
        dx = a.x - b.x;
        dy = a.y - b.y;
        d = Math.sqrt(dx * dx + dy * dy);
        if (d > 0 && d < 80) {
          F = (g * 1) / d;
          fx += F * dx;
          fy += F * dy;
        }
      }
      a.vx = (a.vx + fx) * 0.5;
      a.vy = (a.vy + fy) * 0.5;
      a.x += a.vx;
      a.y += a.vy;
      if (a.x <= 0 || a.x >= 500) { a.vx *= -1; }
      if (a.y <= 0 || a.y >= 500) { a.vy *= -1; }
    }
  };
  yellow = create(200, "yellow");
  red = create(200, "red");
  green = create(200, "green");
  update = () => {
    rule(green, green, -0.32);
    rule(green, red, -0.17);
    rule(green, yellow, 0.34);
    rule(red, red, -0.1);
    rule(red, green, -0.34);
    rule(yellow, yellow, 0.15);
    rule(yellow, green, -0.2);
    m.clearRect(0, 0, 500, 500);
    draw(0, 0, "black", 500);
    for (i = 0; i < atoms.length; i++) {
      draw(atoms[i].x, atoms[i].y, atoms[i].color, 5);
    }
    requestAnimationFrame(update);
  };
  update();
</script>

Tópicos relacionados: Simulación de vida de partículas, Sopa primordial - Evolución, El juego de la vida de Conway, Autómatas celulares, Patrones de autoorganización,

Este proyecto se inspiró en: Clusters http://www.ventrella.com/Clusters/ de Jeffery Ventrella. No tengo acceso al código de Ventrella, pero supongo que la principal diferencia de este proyecto con respecto a los otros proyectos de vida de partículas es que no implementé la detección de colisiones y esto hizo posible la simulación de miles de partículas en tiempo real. Además, agregué controles gui para cambiar los parámetros en tiempo real, lo que permite un fácil ajuste y exploración, por lo tanto, pude encontrar algunos patrones nunca antes vistos que emergen de algunos modelos de relaciones extremadamente simples. El código aquí es probablemente un orden de magnitud más simple que cualquier otro código de Vida Artificial porque comencé este código únicamente como un material educativo para no programadores y audiencia general para demostrar el punto de que la complejidad puede surgir de la simplicidad.

Todos:

  1. Agregar la capacidad de guardar y cargar parámetros (para que las personas puedan compartir fácilmente los modelos interesantes que encuentren)
  2. Capacidad para agregar más tipos de partículas (actualmente se fija a cuatro tipos de partículas)
  3. Actualmente, el mayor cuello de botella son los bucles anidados (que calculan la distancia por pares entre todas las partículas) haciendo que la complejidad computacional sea cuadrática. Sería increíble si pudiéramos encontrar una manera de evitarlo.
  4. Alternativa al punto 3, calcular las distancias por pares es vergonzosamente paralelo para que se pueda calcular en gpu.
  5. Agregando la capacidad de cambiar el tamaño de la pantalla y mejorando la verificación de límites, ya que muchas partículas que se mueven rápidamente pueden escapar de los límites de la pantalla.
  6. Agregar una interfaz de usuario más intuitiva para que brinde la capacidad de un control más fino sobre los parámetros.
  7. Agregar un botón aleatorio o, mejor aún, tener una meta regla simple para mutar la regla inicial de forma continua y recursiva. ¡De esta manera, los patrones nunca se atascarán en un máximo local y seguirán cambiando!
  8. Una mejor manera de afinar es usar un algoritmo evolutivo para seleccionar y optimizar los parámetros, pero uno necesita escribir una función de aptitud para eso. Actualmente no sé a qué función de acondicionamiento físico corresponde en el ámbito de este programa. En nuestro mundo, la función de acondicionamiento físico es la competencia y la supervivencia del más apto. Sin embargo, aquí afinamos y seleccionamos los parámetros que producen patrones interesantes para nosotros, ¡pero la palabra "interesante" es más fácil de decir que de definir!

Comentarios

Publicar un comentario