Outils pour utilisateurs

Outils du site


figure_de_lichtenberg

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
Prochaine révision
Révision précédente
figure_de_lichtenberg [2019/11/10 10:32]
Mushussu
figure_de_lichtenberg [2020/04/07 17:28] (Version actuelle)
Mushussu [Code]
Ligne 1: Ligne 1:
 ====== Figures de Lichtenberg ====== ====== Figures de Lichtenberg ======
  
-https://​en.wikipedia.org/​wiki/​Lichtenberg_figure+Définition sur [[https://​en.wikipedia.org/​wiki/​Lichtenberg_figure|Wikipedia]] 
 En mode analogique : En mode analogique :
-https://​youtu.be/​1jhqZg8UBJU?​t=145+ 
 +[[https://​youtu.be/​1jhqZg8UBJU?​t=145|Dangerous! Electrifying Woodworking!]]
  
 Sinon d’autres renseignements : Sinon d’autres renseignements :
-http://​capturedlightning.com/​frames/​lichtenbergs.html+ 
 +[[http://​capturedlightning.com/​frames/​lichtenbergs.html|What are Lichtenberg figures, and how do we make them?]]
  
 ==== Illustration ==== ==== Illustration ====
Ligne 14: Ligne 17:
 ==== Théorie ==== ==== Théorie ====
  
-http://​paulbourke.net/​fractals/​dla/​+[[http://​paulbourke.net/​fractals/​dla/​|DLA - Diffusion Limited Aggregation]] 
 + 
 +===== Simulation ===== 
 + 
 +==== Résultat ==== 
 +{{:​dla-002986.png?​400|}} 
 +==== Processing ==== 
 +<code java> 
 +ArrayList<​Marcheur>​ arbre; 
 +ArrayList<​Marcheur>​ marcheurs;​ 
 +int nombreMarcheurs = 2000; 
 +int rangMax = 0; 
 + 
 + 
 +void setup() { 
 +  size(1600, 1000); 
 +  arbre = new ArrayList<​Marcheur>​();​ 
 +  arbre.add(new Marcheur(width / 2, height)); 
 +  marcheurs = new ArrayList<​Marcheur>​();​ 
 +  for (int i = 0; i < nombreMarcheurs;​ i++) { 
 +    marcheurs.add(new Marcheur());​ 
 +  } 
 +
 + 
 +void draw() { 
 +  background(0);​ 
 +  for (int i = marcheurs.size() - 1; i >= 0; i--) { 
 +    Marcheur m = marcheurs.get(i);​ 
 +    m.rafraichir();​ 
 +    //​m.afficher(rangMax);​ 
 +    for (int j = 0; j < arbre.size();​ j++) { 
 +      Marcheur ma = arbre.get(j);​ 
 +      if (m.position.dist(ma.position) < (2 * ma.rayon - 4)) { 
 +        if (m.position.y < ma.position.y) { 
 +          marcheurs.remove(m);​ 
 +          m.rayon = ma.rayon * 0.97; 
 +          m.rang = ma.rang + 1; 
 +          m.parent = ma; 
 +          if (m.rang > rangMax) { 
 +            rangMax = m.rang; 
 +          } 
 +          arbre.add(m);​ 
 +          break; 
 +        } else { 
 +          m.position = haut(); 
 +        } 
 +      } 
 +    } 
 +  } 
 +  for (int i = arbre.size() - 1; i >= 0; i--) { 
 +    Marcheur ma = arbre.get(i);​ 
 +    ma.afficher(rangMax);​ 
 +  } 
 +  if (marcheurs.size() == 0) { 
 +    affichageArbre();​ 
 +    println(rangMax);​ 
 +    saveFrame("​images/​DLA-######​.png"​);​ 
 +    noLoop(); 
 +  } 
 +
 + 
 +void affichageArbre() { 
 +  background(0);​ 
 +  for (int j = 1; j < arbre.size();​ j++) { 
 +    Marcheur ma1 = arbre.get(j);​ 
 +    Marcheur ma2 = ma1.parent;​ 
 +    stroke(255);​ 
 +    strokeWeight(ma2.rayon / 3.5); 
 +    line(ma1.position.x,​ ma1.position.y,​ ma2.position.x,​ ma2.position.y);​ 
 +  } 
 +
 + 
 +class Marcheur { 
 +  PVector position;  
 +  Marcheur parent; 
 +  float rayon; 
 +  int rang; 
 + 
 +  Marcheur() { 
 +    position = haut(); 
 +    rayon = 15; 
 +    rang = 0; 
 +  } 
 + 
 +  Marcheur(int x, int y) { 
 +    position = new PVector(x, y); 
 +    rayon = 30; 
 +    rang = 0; 
 +  } 
 + 
 +  void rafraichir() { 
 +    PVector vitesse = PVector.random2D().setMag(30);​ 
 +    position.add(vitesse);​ 
 +    position.x = constrain(position.x,​ 0, width); 
 +    position.y = constrain(position.y,​ 0, height); 
 +  } 
 + 
 +  void afficher(int r) { 
 +    noStroke();​ 
 +    int teinte = (int)map(rang,​ 0, r, 255, 10); 
 +    fill(teinte);​ 
 +    ellipse(position.x,​ position.y, 2 * rayon, 2 * rayon); 
 +  } 
 +
 + 
 +PVector pourtour() { 
 +  int a = (int)random(3);​ 
 +  if (a == 0) { 
 +    float r = random(width);​ 
 +    return new PVector(r, 0); 
 +  } else if (a == 1) { 
 +    float t = random(height);​ 
 +    return new PVector(0, t); 
 +  } else { 
 +    float u = random(width);​ 
 +    return new PVector(width,​ u); 
 +  } 
 +
 + 
 +PVector haut() { 
 +  float r = random(width);​ 
 +  return new PVector(r, 0); 
 +
 + 
 +float distSq(PVector a, PVector b) { 
 +  float dx = b.x - a.x; 
 +  float dy = b.y - a.y; 
 +  return dx * dx + dy * dy; 
 +
 +</​code>​ 
 + 
 +==== Processing 3D ==== 
 + 
 +Voici le code avec exportation .png et .stl : 
 +<code java> 
 +import java.io.*;​ 
 +import peasy.PeasyCam;​ 
 + 
 +PeasyCam cam; 
 +File repertoire;​ 
 + 
 + 
 +ArrayList<​Marcheur>​ arbre; 
 +ArrayList<​Marcheur>​ marcheurs;​ 
 +int nombreMarcheurs = 1000; 
 +int limite = 800; 
 +int rangMax = 0; 
 + 
 +public void settings() { 
 +  size(1000, 1000, P3D); 
 +  arbre = new ArrayList<​Marcheur>​();​ 
 +  arbre.add(new Marcheur(0, 0, 0, limite)); 
 +  marcheurs = new ArrayList<​Marcheur>​();​ 
 +  for (int i = 0; i < nombreMarcheurs;​ i++) { 
 +    marcheurs.add(new Marcheur(limite));​ 
 +  } 
 +
 + 
 +public void setup() { 
 +  cam = new PeasyCam(this,​ 400); 
 +    repertoire = new File(sketchPath());​ 
 + 
 +
 + 
 +public void draw() { 
 +  lights(); 
 +  scale(1); 
 +  rotateX(PI/​2);​ 
 +  background(0);​ 
 +  for (int i = marcheurs.size() - 1; i >= 0; i--) { 
 +    Marcheur m = marcheurs.get(i);​ 
 +    m.rafraichir();​ 
 +    //​m.afficher(1);​ 
 +    for (int j = 0; j < arbre.size();​ j++) { 
 +      Marcheur ma = arbre.get(j);​ 
 +      if (dist3DSq(m.position,​ ma.position) < (4 * ma.rayon * ma.rayon)) { 
 +        if (m.position.z > ma.position.z) { 
 +          marcheurs.remove(m);​ 
 +          m.rayon = ma.rayon * 0.97; 
 +          m.rang = ma.rang + 1; 
 +          m.parent = ma; 
 +          if (m.rang > rangMax) { 
 +            rangMax = m.rang; 
 +          } 
 +          arbre.add(m);​ 
 +          break; 
 +        } else { 
 +          m.position = pourtour(limite);​ 
 +        } 
 +      } 
 +    } 
 +  } 
 +  affichageArbre(arbre);​ 
 +  if (marcheurs.size() == 0) { 
 +    println(rangMax);​ 
 +  } 
 +
 + 
 +void affichageArbre(ArrayList<​Marcheur>​ a) { 
 +  background(0);​ 
 +  for (int j = 1; j < a.size(); j++) { 
 +    Marcheur ma1 = a.get(j); 
 +    Marcheur ma2 = ma1.parent;​ 
 +    stroke(255);​ 
 +    strokeWeight(ma2.rayon / 3.5); 
 +    line(ma1.position.x,​ ma1.position.y,​ ma1.position.z,​ ma2.position.x,​ ma2.position.y,​ ma2.position.z);​ 
 +  } 
 +
 + 
 +void keyPressed() { 
 +  if (key == ' ') { 
 +    saveFrame("​images/​DLA3D-######​.png"​);​ 
 +  } 
 +  if (key == '​e'​) { 
 +    exporterSTL(arbre);​ 
 +  } 
 +
 + 
 +void exporterSTL(ArrayList<​Marcheur>​ a) { 
 +  String ligne = "​[";​ 
 +    for (int j = 1; j < a.size(); j++) { 
 +      if (j != 1) { 
 +        ligne += ",";​ 
 +      } 
 +      Marcheur ma1 = a.get(j); 
 +      Marcheur ma2 = ma1.parent;​ 
 +      String p1 = "​["​ + ma1.position.x + ","​ + ma1.position.y + ","​ + ma1.position.z + "​]";​ 
 +      String p2 = "​["​ + ma2.position.x + ","​ + ma2.position.y + ","​ + ma2.position.z + "​]";​ 
 +      ligne += "​[["​ + p1 + ","​ + ma1.rayon / 3.5 + "​],"​ + "​["​ + p2 + ","​ + ma2.rayon / 3.5 + "​]]";​ 
 +    } 
 +    ligne += "​]";​ 
 +    println(ligne);​ 
 +    String[] cmd = {"/​Applications/​OpenSCAD.app/​Contents/​MacOS/​OpenSCAD",​  
 +      "​-o",​  
 +      "​Arbre.stl",​  
 +      "​-D",​  
 +      "u = " + ligne,  
 +      "​Arbre.scad"​};​ 
 +       
 +    Process p; 
 +    try { 
 +      p = Runtime.getRuntime().exec(cmd,​ new String[0], repertoire);​ 
 +      p.waitFor();​ 
 +      float error = p.exitValue();​ 
 +      println("​Erreur = " + error); 
 +    }  
 +    catch (InterruptedException e) { 
 +      e.printStackTrace();​ 
 +    }  
 +    catch (IOException e) { 
 +      e.printStackTrace();​ 
 +    } 
 +
 + 
 +class Marcheur { 
 +  PVector position;  
 +  Marcheur parent; 
 +  float rayon; 
 +  int rang; 
 +  int limite; 
 + 
 +  Marcheur(int l) { 
 +    limite = l; 
 +    position = pourtour(limite);​ 
 +    rayon = 15; 
 +    rang = 0; 
 +  } 
 + 
 +  Marcheur(int x, int y, int z, int l) { 
 +    limite = l; 
 +    position = new PVector(x, y, z); 
 +    rayon = 30; 
 +    rang = 1; 
 +  } 
 + 
 +  void rafraichir() { 
 +    PVector vitesse = PVector.random3D().setMag(30);​ 
 +    position.add(vitesse);​ 
 +    position.setMag(constrain(position.mag(),​ 0, limite)); 
 +  } 
 + 
 +  void afficher(int r) { 
 +    noStroke();​ 
 +    int teinte = (int)map(rang,​ 0, r, 255, 10); 
 +    fill(teinte);​ 
 +    pushMatrix();​ 
 +    translate(position.x,​ position.y, position.z);​ 
 +    sphere( 2 * rayon); 
 +    popMatrix();​ 
 +  } 
 +
 + 
 +PVector pourtour(int l) { 
 +  PVector v = PVector.random3D().setMag(l);​ 
 +  v.z = abs(v.z); 
 +  return v; 
 +
 + 
 +float dist3DSq(PVector a, PVector b) { 
 +  float dx = b.x - a.x; 
 +  float dy = b.y - a.y; 
 +  float dz = b.z - a.z; 
 +  return dx * dx + dy * dy + dz * dz; 
 +
 +</​code>​ 
 + 
 +Pour la partie OpenSACD de l'​exportation .stl : 
 +<code c> 
 +$fn = 15; 
 + 
 +u = [[[[10, 10, 10], 30], [[30, 20, 40], 20]], [[[30, 20, 40], 20], [[60, 30, 45], 10]]];
  
 +for (i = [0:len(u) - 1]) {
 +    element(u[i]);​
 +}
  
 +module element(e) {
 +    a = e[0];
 +    b = e[1];
 +    hull() {
 +        translate(a[0]) sphere(d = a[1]);
 +        translate(b[0]) sphere(d = b[1]);
 +    }
 +}
 +</​code>​
 ==== Code ==== ==== Code ====
 === Heightmap === === Heightmap ===
  
-https://​forum.processing.org/​two/​discussion/​25167/​fly-over-a-heightmap-generated-landscape+[[https://​forum.processing.org/​two/​discussion/​25167/​fly-over-a-heightmap-generated-landscape|v]]
  
 === Agrégation limitée par la diffusion (DLA) === === Agrégation limitée par la diffusion (DLA) ===
  
-https://​medium.com/​@jason.webb/​simulating-dla-in-js-f1914eb04b1d+[[https://​medium.com/​@jason.webb/​simulating-dla-in-js-f1914eb04b1d|Simulating 2D diffusion-limited aggregation (DLA) with JavaScript]]
  
-https://​thecodingtrain.com/​CodingChallenges/​034-dla.html+[[https://​thecodingtrain.com/​CodingChallenges/​034-dla.html|Diffusion-Limited Aggregation]]
  
-https://​www.openprocessing.org/​sketch/​460864+[[https://​www.openprocessing.org/​sketch/​460864|Challenge #34: Diffusion-Limited Aggregation]]
  
-{{tag>​processing sylvain}}+{{tag> processing sylvain}}
figure_de_lichtenberg.1573378322.txt.gz · Dernière modification: 2019/11/10 10:32 par Mushussu