[Introduction]
J'ai lu "The Secret Concis". Il y a un chapitre qui présente plusieurs méthodes d'utilisation du bruit pour générer des graphiques fractaux. Cela semble très intéressant, j'ai donc essayé d'utiliser un ordinateur pour le simuler, et l'effet n'est pas mauvais (la méthode de bruit est plus facile à mettre en œuvre dans la programmation que la méthode itérative traditionnelle. Plus tard, j'ai trouvé qu'il existe encore de nombreux algorithmes, donc je peux en trouver plus à la recherche de chaosgame).
[Méthode de génération de bruit de triangle Sierpinski]
Dans ces jeux de bruit, les règles de génération de triangles de Sierpinski sont les plus faciles:
1. Sélectionnez trois points de l'avion, marqués en 1, 2 et 3, comme sommets du grand triangle.
2. Sélectionnez l'un d'eux comme "point actuel" (comme la sélection n ° 1).
3. Générer un nombre aléatoire de 1 à 3, dessiner un nouveau point au milieu du sommet et le "point de courant" exprimé par le nombre et utiliser le nouveau point comme "point de courant".
4. Répétez l'étape 3 pour se rapprocher du motif.
*. Faites attention aux nombres aléatoires, il est préférable de ne pas utiliser le temps comme mode de génération de graines.
[Programme de simulation]
package com.geiv.chaos; import java.awt.event.keenvent; import com.thrblock.util.randomset; import geivcore.defaultfactor; import geivcore.keyfactor; import geivcore.keylistener; import geivcore.r; import geivcore.uesi; importer geivcore.enginedata.obj.obj; DefaultFactor implémente keyListener {uesi ues; obj [] baspoint; obj crtpoint; public sierpinski (uesi ues, int times) {this.ues = ues; basepoint = new obj [3]; // créer trois points de référence pour (int i = 0; i <3; i ++) {basique [I] Ues.creatObj (uesi.bgindex); basepoint [i] .addglpoint ("70dbdb", 0,0); baspoint [i] .show ();} baspoint [0] .setcentralx (400); // définit la position à trois points BasEpoint [0] .setCentraly (60); BasEpoint [1] .SetCentralx (60); Basepoint [1] .setCentraly (550); BasEpoint [2] .SetCentralx (740); BasEpoint [2] .SetCentRaly (550); CrtPoint = Basepoint [0]; // prendre le point 0 comme point actuel (550); this.setKeyListener (this); ues.pushkeyboardo (this); for (int i = 0; i <times; i ++) {generaTenew ();}} @ override public void dokeybord (keyfactor who, int keycode, boolean ispregh) {// mont cap Le point correspondant à generaTenew ();} else if (keycode == keyevent.vk_a) {// a correspond à 100 nouveaux points pour (int i = 0; i <100; i ++) {generaTenew ();}} else if (keycode == keyevent.vk_b) {/ b correspond à 1000 nouveaux points pour (int i = 0; i <i; 1000; i ++) {GeneraTenew ();}}}}} public void generaTenew () {obj flagPoint = baspoint [randomset.getRandomnum (0, 2)]; // sélectionnez au hasard l'un des points de référence float nx = (drapeau (Flagpoint.getCentraly () + crtpoint.getCentraly ()) / 2f; obj newpoint = ues.creatoBj (uesi.bgindex); // Créer un nouveau point newpoint.addglpoint ("70dbdb", 0,0); newpoint.setColor (randomset.getromColdColor ()); newpoint.set.setcral (nx); / set the coordonnées newpoint.setcentraly (NY); newpoint.show (); crtpoint = newpoint; // défini comme point actuel} public static void main (String [] args) {uesi ues = new r (); new sierpinski (ues, 0); // Les paramètres de construction des sous-suites peuvent définir le nombre initial de points. }}[Résultats de la simulation]
Lorsque la touche b est enfoncée
[Méthode de génération de bruit de Barnsleyfern]
Comparé à la simple régularité du triangle de Sierpinski, Barnsleyfern (Fractal Tooth Grass) donne aux gens une impression plus complexe. En raison de sa complexité, la discipline du chaos apparaît souvent pour prouver la conclusion que "les règles simples peuvent également produire des objets complexes".
Ses règles de génération ne sont pas non plus compliquées:
1. Premièrement, étant donné le "point de courant" (0,0), nous utilisons Ox et OY pour représenter les coordonnées horizontales et verticales.
2. Pour calculer le point suivant (NX, NY), vous devez sélectionner l'une des quatre formules d'itération suivantes avec certaines règles aléatoires:
1) Sélectionnez cette formule d'itération avec la probabilité de% 1:
nx = 0;
NY = 0,16f * oy;
2) Sélectionnez cette formule d'itération avec la probabilité de% 85:
nx = 0,85 * ox + 0,04 * oy;
NY = -0,04 * OX + 0,85 * OY + 1,6;
3) Sélectionnez cette formule d'itération avec la probabilité de% 7:
nx = 0,2 * ox-0,26 * oy;
NY = 0,23 * OX + 0,22 * OY + 1,6;
4) Sélectionnez cette formule d'itération avec la probabilité de% 7:
nx = -0,15 * ox + 0,28 * oy;
NY = 0,26 * OX + 0,24 * OY + 0,44;
3. Draw (NX, NY), le définissez sur le point actuel, répétez 2, et vous pouvez approximer le résultat infiniment.
↑ La formule ci-dessus est extraite de Wiki: http://en.wikipedia.org/wiki/Barnsley_fern. Lors de la programmation, j'ai trouvé un problème. Le wiki n'a pas spécifié la relation entre la valeur relative de cette coordonnée et la taille de l'écran, ni spécifié la direction des axes x et y. Le dessin a toujours échoué dans le système de coordonnées que j'ai défini. Plus tard, j'ai recherché selon la formule et j'ai trouvé cette surface: http://people.sc.fsu.edu/~jburkardt/cpp_src/fern_opengl/fern.cpp. Il s'agit d'un programme OpenGL en C ++, et la même formule que Wiki est utilisée. C'est-à-dire que cet ensemble de formules est basé sur le système de coordonnées d'OpenGL. Après avoir fait la transformation correspondante, il a finalement été dessiné avec succès.
[Programme de simulation]
package com.geiv.chaos; importer geivcore.defaultfactor; import geivcore.keyfactor; import geivcore.keyListener; import geivcore.r; importer geivcore.uesi; import geivcore.engineata.obj.obj; com.thrBlock.util.randomset; public class Barnsleyfern étend defaultFactor implémente keyListener {uesi ues; obj crtpoint; public barnsleyfern (uesi ues, int times) {this.ues = ues; crtpoint = Ues.creatObj (uesi.bgindex); crtpoint.addglpoint ("70dbdb", 0,0); crtpoint.show (); crtpoint.setCentralx (0); crtpoint.setcentraly (0); ues.setViewoffSetx (90); this.setkeyListener (this); ues.push Times; i ++) {generaTenew ();}} @ Override public void dokeybord (keyfactor qui, int keycode, booléen ispresmpe Keyevent.vk_a) {for (int i = 0; i <100; i ++) {generaTenew ();}} else if (keycode == keyevent.vk_b) {for (int i = 0; i <100; i ++) {generaTenew ();}} else if (keycode == keyevent.vk_b) {pour (ist 0; 1000; i ++) {GeneraTenew ();}}}} public void generaTenew () {float nx, ny; float ox = crtpoint.getcentralx () / 150f, oy = (600 - crtpoint.getcentraly ()) / 60f; // La conversion de coordonnées est effectuée ici, et la correspondance dans la vue est inversée. Double code = 100.0 * randomset.getrandomfloatin_1 (); // Numéro de point flottant aléatoire 0 ~ 100 if (code> = 0 && code <= 1) {nx = 0; NY = 0.00f * ox + 0.16f * oy;} else if (Code> 1 && code <= 86) {nx = 0.85f * ox + 0,04f * oy + 0,85f * oy + 1,6f;} else if (code> 86 && code <= 93) {nx = 0,2f * ox - 0,26f * oy; ny = 0.23f * ox + 0,22f * oy + 1.6f;} else {nx = -0,15f * ox + 0,28f * oy; ny = 0,26f * ox + 0,24f * oy + oy; ny = 0,26f * ox + 0,24f * oy + oy; ny = 0,26f * ox + 0,24f * oy + oy; ny = 0,26f * ox + 0,24f * oy + oy; ny = 0,26f * ox + 0,24f * oy + oy; 0.44f;} obj newpoint = ues.creatObj (uesi.bgindex); newpoint.addglpoint ("70dbdb", 0,0); newpoint.setColor (Color.Green); newpoint.setcentralx (nx * 150f); // annuler la transformation coordonnée précédente newpoint.setCentCentraly (600 - NY * 60F); newpoint.show (); crtpoint = newpoint; // définit le nouveau point sur le point actuel. } public static void main (String [] args) {uesi ues = new r (); new Barnsleyfern (ues, 0);}}[Résultats de la simulation]
Résumer
Ce qui précède est tout le contenu de cet article sur le code de jeu Java Chaos Game Noise, j'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!