Xeno, can you elaborate a bit more on how you created this spiral like triangle inequality looking pattern? Do you mind providing some code?

There are two parts to it. For the branching pattern you can use triangle inequality or some variation of it and it will work just as well. The second part is the swirly effect, and it doesn't matter what pattern you use it with. This is a transformation of coordinates applied in the iteration, before the z²+c. Any transformation can be used but it should be confined to a local area. So it's like an orbit trap except instead of bailing out, you modify the coordinates. It usually works best if you keep the effect away from the set boundary so it only modifies the coloring in the exterior or interior regions but some good effects can be had with boundary distortion. Also it works best in Julia sets rather than Mandelbrot.

Swirl type transformations are just rotations around the center, and the main variables are the maximum radius and how the rotation amount depends on the radius. In this case you don't want the classic Swirl as used in flame fractals, but a kind of inverse effect, as you want the rotation to taper off to none at the maximum radius (you don't have to, but I prefer smooth transitions). I've called it Vortex or Vortices where I've used it in other contexts. I used (1-r)³ for the rotation scaling in this case.

Exterior field lines.jpg

My try to do similar:

• binary decomposition + level sets of escape time gives cells : z -> cimage(final_z) , final_iteration,
• normalize point z from each into [0,1]x[0,1] range
• apply procedural 2D texture for each cell



double GiveGray(const double x, const double y, const int n){


double d =  max(fabs(x - 0.5) ,fabs(y-0.5));
  return d;
  }


unsigned char ComputeColorOfTexture(complex double z, const int k){

 int nMax = iterMax_LSM;
  double cabsz;
  unsigned char iColor;

  int n;

  for (n=0; n < nMax; n++){ //forward iteration
cabsz = cabs(z);
    if (cabsz > ER_LSM) break; // esacping
   
   
      z = z*z +c ; /* forward iteration : complex quadratic polynomial */
  }
 
       double final_angle = c_turn(z); // in [0,1] range
   
  double y = frac(n-log(log(cabsz)));
  // inside each cell point has additional coordinate w = (final_angle, final_radius) in [0,1]x[0,1]
  double gray = GiveGray(final_angle, y, k);
  iColor = gray*255;
 

 
  return iColor;


}
The image is not so cool as  Exterior field lines.jpg  by xenodreambuie, but IMHO the algorithm is similar. Am I right ?


Diferences : 

• colors
• 4 not 8 arm star
• c is different

btw: I failed to make 8 arm star. Found    https://www.iquilezles.org/www/articles/distfunctions2d/distfunctions2d.htm Maybe it will help.

My try to do similar:

• binary decomposition + level sets of escape time gives cells : z -> cimage(final_z) , final_iteration,
• normalize point z from each into [0,1]x[0,1] range
• apply procedural 2D texture for each cell

Code: [Select]



double GiveGray(const double x, const double y, const int n){


double d =  max(fabs(x - 0.5) ,fabs(y-0.5));
  return d;
  }


unsigned char ComputeColorOfTexture(complex double z, const int k){

 int nMax = iterMax_LSM;
  double cabsz;
  unsigned char iColor;

  int n;

  for (n=0; n < nMax; n++){ //forward iteration
cabsz = cabs(z);
    if (cabsz > ER_LSM) break; // esacping
   
   
      z = z*z +c ; /* forward iteration : complex quadratic polynomial */
  }
 
       double final_angle = c_turn(z); // in [0,1] range
   
  double y = frac(n-log(log(cabsz)));
  // inside each cell point has additional coordinate w = (final_angle, final_radius) in [0,1]x[0,1]
  double gray = GiveGray(final_angle, y, k);
  iColor = gray*255;
 

 
  return iColor;


}
The image is not so cool as  Exterior field lines.jpg  by xenodreambuie, but IMHO the algorithm is similar. Am I right ?

Yes, the algorithm is right, just a few details can be improved.

The gray value needs multiplying by 2 to go from 0 to 1.

The continuous potential formula doesn't align properly with iteration bands, so the texture is truncated. The formula I use is from Gert Buschmann:

potential = n - velocity*(log(log(cabsz)) - Lbr)
where velocity = 1/log(min(2,degree)) // degree of formula, ie 2 for this
and Lbr = log(log(ER_LSM)) // double log of the squared bailout radius

This gives the picture below.
I call this texture pyramids.
My code in Pascal for the Star8 texture is:

// r is the smooth potential and phi is the final angle
function Star8(const r,phi: double):double;
var fr,fphi,t: single;
begin
  fr:= Abs(Abs(Frac(r))*2-1);
  fphi:= Abs(Abs(Frac(phi))*2-1);
  if fphi>fr then begin
    t:= fr; fr:= fphi; fphi:=t;
  end;
  Result:= 1+1.5*fphi-2.5*fr;
  t:= 1-2.5*fphi-fr;
  if t>Result then result:=t;
  if Result<0 then result:=0;
end;



thx for the answer

I like Gert images and programs,
http://www.juliasets.dk/RatioField.htm
Can you describe and show the code for filed lines ?

That page has a good general description of field lines for interior regions of Julia sets, but lacks the theory. He has the basic theory in the Field Lines section of this page, not far from the top:
http://www.juliasets.dk/Pictures_of_Julia_and_Mandelbrot_sets.htm
It's not a very clear explanation though. Here are the key points:

The field angle is a continuous quantity but it's not just the final angle of the iteration.
For interior regions you will already be doing some pre-processing: finding each critical point and iterating them to find the attractor point. In addition you need to iterate further to find the period, and calculate the final angle theta of the attractor.

Then in the iterations of the Julia set, as well as testing high bailout for escape, you will be testing each finite attractor for convergence within low bailout tolerance.
If the iterations converge, then using the properties of the attractor:
The proper iteration count N = floor(iterations/period)
The field angle phi = final angle of iteration - N*theta

Since the field angle is continuous, you can use any algorithm you like to divide it into bands, and you can use it along with smooth potential as coordinates for continuous texture.

For simple field lines, some periodic function of phi (eg sine, triangle or square), with scaling and truncation to make gaps between the lines. As well as using the result for coloring, you can use it to alphablend with background coloring based on potential, distance estimate or something else.

Now I have 39 ways

New potential

Nice work, I like the ones with the contours. ...

I would like to try to make one myself, what is the simplest way to plot a Julia set?

Is there something very simple like that for Julia sets?  Are they more complicated to plot?  Can you use the same method but instead swap Z with C?

You can try. Code is here https://gitlab.com/adammajewski/implodedcauliflower/-/blob/master/src/d.c

from console  to compile : gcc d.c -lm -Wall -march=native -fopenmp

and to run: ./a.out


Feel free to ask.

The difference between parameter and dynamic plane ....


Please install mandel https://www.mndynamics.com/indexp.html which has many demos and explanations.

In general : Start from dynamic palne . Here you iterate z points, here is Julia set.

On the parameter plane the is no iteration ( maybe only Newton). Here is Mandelbrot set. But if you compute Julia set ( dynamic plane) then for each c point switch to dynamic plane  and check what happens , Then go back to parameter plana and colut pixel.

HTH

somewhat prettier colour scheme

I am willing to experiment.  Do you mind elaborating what these are?

potential ( radial part) and  ? SAC as an angular part  as a coordinate system