END OF AN ERA, FRACTALFORUMS.COM IS CONTINUED ON FRACTALFORUMS.ORG

One can grow DLA using field lines by creating a single attracting point, creating a particle on the border of a random shape, and iterate how the particle falls into the attractor. When it hits, the last “segment” of the field line is plotted, and registered as a new attractor. This creates the aggregation. The end result can be efficient because the paths of particles follow field lines instead of random walks. Every thing is deterministic except for the initial origin position the the particle, or field walker if you will. A walker is created in a random location, then follows its field line to the cluster of attracting points. The end result of iteration, looks virtually identical to random “drunken” walk based DLA.

0: Create a vector field.
1: Add a single attractor A to the field.
2: Create a random point P.
3: Walk P along its field line until it hits an attractor H.
4: Draw the last segment of P's walk to H.
5: Add the attractor H to the field.
6: Goto step 2



FWIW, here is some sample/crude code that depend on the Cairo graphics and GLM vector math libraries:


https://github.com/ChrisMThomasson/CT_fieldDLA/tree/master/cairo_test_penrose

https://plus.google.com/101799841244447089430/posts/TdfDCDwkEXf

https://plus.google.com/101799841244447089430/posts/7LQhwQVi86V

https://plus.google.com/101799841244447089430/posts/gZcisaoMdSV

https://plus.google.com/101799841244447089430/posts/NmsLw9xVmZL

https://plus.google.com/101799841244447089430/posts/PPFtCUuuDkL


IMVHO, this is interesting...  ;^)

Here is the output of the program:

https://github.com/ChrisMThomasson/CT_fieldDLA/blob/master/cairo_test_penrose/output.png

You should get this rendering.

Thank you so much! I worked very hard on this in my fairly limited free time, and one of the nice things about it is that it ties directly into field based diffusion limited aggregation. This is basically the direct opposite of the random, perhaps "drunken" walk method. The field based method pulls particles into the attractors quite nicely. And DLA can, and does occur using:

0: Create a vector field.
1: Add a single attractor A to the field.
2: Create a random point P.
3: Walk P along its field line until it hits an attractor H.
4: Draw the last segment of P's walk to H.
5: Add the attractor H to the field.
6: Goto step 2

Well, this is the smallest amount of steps I can reduce the algorithm to. Can anybody go smaller, a faster wrt the aggregation process of field DLA?

 FWIW, here is a link to a crude pre-alpha test of an animated vector field. Can you please test this out and tell me if it works for you:

http://funwithfractals.atspace.cc/ct_fdla_anime_test_0

You should see a vector field start to emerge in blue. Does it work for you, does it go too fast? Too slow?

Also, let it run until a little alert box pops up saying its done. I would not recommend trying this out on a phone. It will work, but should be fairly slow. ;^o

Thanks everybody!

 

Thank you for giving it a go! I am wondering if you let it run long enough to get the alert box saying its done? If so, how long did it take? The number of simultaneous points for the vector field being rendered is a bit high for a phone. Humm. Also, can you save the rendering to your phone storage? It should be 1920x1080.

Yup, I was worried about that. Well, at least you did not say it totally locked up the browser! 

I have a phone to test on now, and will find optimal simulation parameters to make it run nice and smooth.

Thank you for all of your help!

 

FWIW, here is a test page that should show a fairly smooth animation on a phone:

http://funwithfractals.atspace.cc/ct_fdla_anime_test_0_cp/

The end result is the following rendering:

https://plus.google.com/101799841244447089430/posts/ZDr3iwRifsq

This should work way faster than the previous test on a phone.   

Here is a result of a deterministic process of field based DLA. Each field walker starts from the same place over and over again. The vector field is changing wrt particle stick events for new points are dynamically added: