Very simple formula for fractal patterns

[Pauldelbrot]

Your code does look right.

The real (x axis) coords for Z go from approx -4 to +4
The imaginary (Y axis) coords go from approx -7 to -2

Using that framing rect I still don't get exactly the same shapes:

This is how I do it... the references to .x and .y are for the real and imaginary components of the complex number.
cone is initialised to real=1, imag=0

if z.x>0 then z.x:=-z.x;
tmpc:=cadd(cmult(z,c),cone);
tmpc.x:=abs(tmpc.x);
tmpc.y:=abs(tmpc.y);
z:=cadd(tmpc,cdiv(cone,tmpc));

OK so far...

CSet(z.x,z.y,cfrectangular);

Whoa, what's that?

...

On closer inspection, there is a clear parallel between my image and yours if one of them is flipped vertically. It looks like the coloring is what's not matching up. Yours has four-armed spirals where blue and brown alternate going around the spiral; mine have such in corresponding spots but they have blue in the center and brown outside instead. So either my implementation of exponential smoothing is going nuts or you used something slightly different from that.

Also, how many iterations did you use? That last one of mine used 70.

[Pauldelbrot]

I've got it! I tried, for some reason, changing the coloring code to apply the divergent form of exponential smoothing (despite it being trapped points being rendered) and got nearly identical results to yours:



Now to explore this beautiful fractal world some more. Thanks!

[M Benesi]

  Awesome images (read the whole thread)!  Didn't even notice this thread until today.... wow.

  There are a few 3d BS formulas that Jesse coded into Mandelbulber (from an old thread)... don't recall if we took 'em to negative powers however.  Gonna take one for a spin now. 

[Alef]

Could the be modified to generate quazicristaline middle eastern like pattern?

http://en.wikipedia.org/wiki/Girih_tiles#Mathematics_of_girih_tilings

 2007, Peter J. Lu of Harvard University and Professor Paul J. Steinhardt of Princeton University published a paper in the journal Science suggesting that girih tilings possessed properties consistent with self-similar fractal quasicrystalline tilings such as Penrose tilings (presentation 1974, predecessor works starting in about 1964) predating them by five centuries.

This finding was supported both by analysis of patterns on surviving structures, and by examination of 15th century Persian scrolls. However, we have no indication of how much more the architects may have known about the mathematics involved.

Well, it looks similar, but not realy so. Maybe the angle?

[tit_toinou]

Thanks a lot for this topic i'll definitely play with these kind of fractals .

z=abs(z)/abs(c)+c

with Julia values: -0.85,-0.23

<Quoted Image Removed>

Love this fractal !
Changing a little bit the c, and with a different coloring method i get (zooming and zooming) :

[Alef]

I think, this is the best formula ever, of corse exept the original mandelbrot;)
 Without your post I wouldn't found it in this garganthuan thread.

Do it have any differences compared with z=abs(z)/c+c; do it realy needs second abs? With just one abs it alsou generates some sloped pattern in mandelbrot mode.

[tit_toinou]

@Asdam: Mathematically the formulae is not the same..
However a wide range of iteration formulae with Kali's abs folding function is showing interesting fractal patterns (a lot of theses "entangled trees" by the way).
So your formulae will also generate a fractal .

[tit_toinou]

I've found a formulae for the general case of abs, letting new fractals to be explored !
http://www.fractalforums.com/new-theories-and-research/extended-kaliset-t10372/

[Kali]

Well,

first I want to thank everybody who commented here and all who were interested on this thread, I can believe the huge amount of reads it has! I want to credit again Sam Monnier and Tom Lowe, it was because of their works that I found this tiny formula and it's variations.

However, the 3D version was a bit dissapointing, I expected better results. One reason is that the formula included in Mandelbulb3D is not working very well, is also slow and not easy to handle.

I've got some good results anyway, I think the best is this inside rendering:




Also Traffasel's made some nice videos using his own tool, "Gestaltlupe", with infinite patience I guess, because is very slow as the renderer doesn't use a DE system.

<a href="http://www.youtube.com/v/1q45CN-3SuA&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/1q45CN-3SuA&rel=1&fs=1&hd=1</a>

<a href="http://www.youtube.com/v/o3H0iDTf9oU&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/o3H0iDTf9oU&rel=1&fs=1&hd=1</a>

(in the last one the kaliset is on the first part only)
I think on this images the bailout condition is not quite right, but they still show some interesting shapes.


I've tried several times -with very poor results- to render a 3D kaliset using Syntopia´s Fragmentarium. I couldn't find the right DE to be used, the unconditional sphere inversion is a problem... and with the conditional inversion is not Kaliset anymore, but more close to the box - that's why I called it the "Kalibox" (adding also a translation after the abs fold).

But today I had an idea, to use the 2D formula including 3D rotations. I was doing something like this but with the 2D renderer, using the 3D rotations to alter the results in 2D. In this case the 2D formula is applied on the x-y axis of a rotating 3D space using the DE-renderer and the Mandelbox DE method.

It's maybe just a curiosity, but I liked the strange landscapes this method produces:







(I attached the .frag files)


Perhaps other 2D formulas can be "3D rotated" giving interesting results, I'll try later...

Regards,

Kali

[Pauldelbrot]

Perhaps other 2D formulas can be rotated giving interesting results.

Including the original z² + c?

[Kali]

Including the original z² + c?

I tried but the problem is the distance estimator, still don't know how to handle it 

[simon.snake]

Hi guys

Trying to replicate the original post image in FractInt, with the following formula:

Code:

kaliset {
  x = cx = real(pixel)
  y = cy = imag(pixel)
  z = 0:
  x = abs(x)
  y = abs(y)
  z = z + x * x + y * y
  x = x / z + cx
  y = y / z + cy
  |z| < 4
}

But all it gives me is the following image:



Bearing in mind that FractInt works with complex numbers in its formula parser, I wasn't sure if I had to split out the x and y (real and imaginary) and perform different calculations on each, or to leave them combined.

Also, I've had to guess what the bailout condition is.  Anyone like to correct me?  I would love to get to see this image properly.  Also, what other  settings (for example inside and outside colouring) do I need?

Thanks

Simon

[element90]

There's an error in your implementation, replace the lines after

y = abs(y)

Code:

n = x*x + y*y
x = x/n + cx
y = y/n + cy
/* construct here z from real x and imaginary y */
|z| < limit

I don't know the syntax for constructing a complex number from its components in FractInt, hence the comment where code should be.

It is worth having a variable for limit as it alters the appearance of the image, the higher value the closer to a quarter circle it becomes.

[PhotoComix]

@ Kali

do you think that this can be done also with M3D ?

[element90]

I forgot ...

Kali's original formula doesn't have a bailout and all colouring is "inner" and he likes to use exponential smoothing.

I implemented Kaliset using both Mandelbrot and Julia algorithms in Saturn & Titan as "Hybrid" using C++, the Mandelbrot form is below:

Code:

long double normz = (norm(z) == 0.0L ? 1.0L : norm(z));
z = transform(z);
long double x = real(z)/normz;
long double y = real(z)/normz;
z = alpha*pow(x, beta) + gamma*pow(y, delta)*complex_i + c;

The Julia form add epsilon instead of c. The code fragment is used in the usual Mandelbrot anf Julia algorithm loops.

z, c, alpha, beta, gamma, delta & epsilon are all declared as LongComplex (std::complex<long complex>), complex_i is of course 0.0 + 1.0i, the pow functions raise a long double to a LongComplex power.

The transform function, applies whatever transforms have been configured, for Kaliset the transform is set to strip both the real and imaginary components of their signs. Saturn has several transforms defined for moving the value of z in the complex plane, rotating it about a point, changing signs of the components of z, scaling, circle fold in, circle fold out etc., any number of transforms can be configured in two sets, A and B, one set at a time can be applied to an iteration of the formula, the sequence in which the sets is applied is determined by a sequence string, "A" always applies set A, "AB", first applies set A and then set B i.e. the sets are applied to alternate iterations.

Here are some examples using "Hybrid" (Mandelbrot algorithm version), the last one uses parameters of 1.0 for alpha to delta and hence is the same as Kaliset.



http://fav.me/d3fvgzz



http://fav.me/d3fv9g8



http://fav.me/d3fpi7q



http://fav.me/d3fs1vz