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édentesRévision précédente
Prochaine révision
Révision précédente
figure_de_lichtenberg [2019/11/07 16:03] Mushussufigure_de_lichtenberg [2021/04/21 10:48] (Version actuelle) – [Figures de Lichtenberg] Mushussu
Ligne 1: Ligne 1:
-https://en.wikipedia.org/wiki/Lichtenberg_figure+====== Figures de Lichtenberg ====== 
 + 
 +Définition sur [[https://en.wikipedia.org/wiki/Lichtenberg_figure|Wikipedia]]
  
 En mode analogique : En mode analogique :
-https://www.youtube.com/watch?v=1jhqZg8UBJU+ 
 +[[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?]]
 +
 +[[https://images.wur.nl/digital/collection/coll13/search/page/1|Système racinaire]]
 +
 +==== Illustration ====
 +
 +{{media_07:hydrographie_france.jpg?400|}}
 +
 +==== Théorie ====
 +
 +[[http://paulbourke.net/fractals/dla/|DLA - Diffusion Limited Aggregation]]
 +
 +===== Simulation =====
 +
 +==== Résultat ====
 +{{media_03: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 ====
 +=== Heightmap ===
 +
 +[[https://forum.processing.org/two/discussion/25167/fly-over-a-heightmap-generated-landscape|v]]
 +
 +=== Agrégation limitée par la diffusion (DLA) ===
 +
 +[[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|Diffusion-Limited Aggregation]]
  
-Code +[[https://www.openprocessing.org/sketch/460864|Challenge #34: Diffusion-Limited Aggregation]]
  
-https://forum.processing.org/two/discussion/25167/fly-over-a-heightmap-generated-landscape+{{tag> processing sylvain}}
figure_de_lichtenberg.1573142620.txt.gz · Dernière modification : 2019/11/07 16:03 de Mushussu