Okay, one more. Then I'd better turn my attention to trimming the hedges and other things my wife thinks are important. Fractals don't impress her much. : )

This one has two layers also, the bottom layer's custom mapping is based on the complex distance to the corner coordinates of the image. The custom mapping function for the top layer is similar, but I changed the complex numbers to real plane coordinates with ReIm. Once you get the hang of what's going on in the mapping function, it's pretty easy to explore and come up with some wild and amazing images.

Here's the code:

msr = ResourceFunction["MandelbrotSetRemap"];
myMapping1 = 
  Function[{c, center, corner, maxIterations}, 
   Module[{list, corner2, dist1, dist2},
    corner2 = center + (center - corner);
    dist1 = dist2 = 1000000;
    list = NestWhileList[(
        dist1 = Min[dist1, EuclideanDistance[corner, #]];
        dist2 = Min[dist2, EuclideanDistance[corner2, #]];
        #^2 + c
        ) &,
      0, Abs[#] <= 7 &, 1, maxIterations];
    Abs[dist1 - dist2]]];
img1 = msr[-1.3276 - .06866 I, 108, MaxIterations -> 64, "MappingFunction" -> myMapping1, 
  ColorFunction -> ColorData["LakeColors"], ImageSize -> {1200, 800}];

myMapping2 =
  Function[{c, center, corner, maxIterations}, 
   Module[{list, corner1, corner2, dist1, dist2},
    corner1 = ReIm[corner];
    corner2 = ReIm[center] + (ReIm[center] - corner1);
    dist1 = dist2 = 1000000;
    list = NestWhileList[(
      dist1 = Min[dist1, EuclideanDistance[corner1, #]];
      dist2 = Min[dist2, EuclideanDistance[corner2, #]];
      #^2 + c
    ) &,
  0, Abs[#] <= 7 &, 1, maxIterations];
dist1 - dist2]];
colFn = (Blend[{
  {0, Transparent},
  {.28, RGBColor["#301361"]},
  {.5, RGBColor["#F16A17"]},
  {.77, RGBColor["#FFE07C"]},
  {1, LightYellow}},
 #1] &);
img2 = msr[-1.33 - .1 I, 22, MaxIterations -> 64, "MappingFunction" -> myMapping2,
  ColorFunction -> colFn, ImageSize -> {1200, 800}];
ImageCompose[img1, img2]

Please don't stop :)

Hi Mark,

custom mapping functions take a lot of time to render

Compilation can speed it up significantly. MandelbrotSetRemap uses FunctionCompile internally, using Compile instead here because it is easier to deal with and supports a larger range of built-in functions. NestWhileList is not supported so While is used instead.

myMapping1Compiled = 
 Compile[{{c, _Complex}, {center, _Complex}, {corner, _Complex}, {maxIterations, _Integer}},
  Module[{list = {0. + 0. I}, iter = 0, z = 0. + 0. I},
   While[Abs[z] < 4.0 && iter < maxIterations,
    AppendTo[list, z = z^2 + c]; ++iter];
   Total[Arg[list]]*StandardDeviation[list]],
  CompilationTarget -> "C"]

img1 = msr[-.875 + .256 I, 78, 
  MaxIterations -> 32, 
  "MappingFunction" -> myMapping1Compiled, 
  ColorFunction -> ColorData[{"PlumColors", "Reversed"}], 
  ImageSize -> 2400]

is about 4x faster on my machine.

-- you have earned Featured Contributor Badge Your exceptional post has been selected for our editorial column Staff Picks http://wolfr.am/StaffPicks and Your Profile is now distinguished by a Featured Contributor Badge and is displayed on the Featured Contributor Board. Thank you!

Thanks, Daniel. I think I'll wait and see if anyone in the Community has an idea of how to speed up the code. Functions that take so long to evaluate would not be widely appealing. I'd be willing to collaborate with someone. Writing speedy functions is not my forte. : )

Mandelbrats... lol.

I did pair up with fellow programmer and frequent Community contributor @Rohit Namjoshi to write a resource function called MandelbrotSetRemap. It captures the essence of what I outlined in this article but speeds up the renders with compile and parallel processing. It turned out well. Check it out in the Function Repository.