the bot works by iteratively zooming in. given a view, it computes a bunch of randomly zoomed in pictures, and replaces the view by the zoom that had the best score.

currently it computes 16 zooms at each iteration, and does 10 iterations. ideally the score gradually increases, but that doesn't always happen.

the final iteration's hiscore is rendered bigger.

working on a #bot to automatically explore #fractals for #art

the main problem is devising a fitness function, I came up with this:

1. for each pixel in the fractal, compute the local box dimension of its neighbourhood. use the gray value of each pixel as its measure. use square neighbourhoods of radius 1,3,7,15,..., with simple linear regression to get the slope of the log(measure)/log(neighbourhoodsize) graph

2. compute a histogram of all these dimensions (I simply sorted the array). then take as fitness metric the difference between 25% and 75% through the array: this is typically the width of the central bulge in the histogram.

I came up with this after skimming "Multifractal-based Image Analysis with applications in Medical Imaging" master thesis by Ethel Nilsson http://www8.cs.umu.se/education/examina/Rapporter/EthelNilsson.pdf , viewing the dimension image in geeqie with histogram overlayed was interesting. also inspired by https://mrob.com/pub/muency/deltahausdorffdimension.html

#Mandelbrot / #BurningShip / Mandelbrot #hybrid #fractal #art

Parameter data for #et (usually this is stored in image metadata, but Mastodon strips that out...):

```

MBM

z := z^p + c

z := (|x| + i |y|)^p + c

z := z^p + c

p=2

q=1

d=1.0

e=0.0

a=-0.19713518046622788536003

b=-0.65184481359655471603044

r=1.9073486328125e-6

t=(8.715574274765861e-2,0.9961946980917454,-0.9961946980917454,8.715574274765861e-2)

n=4096

de=1.0

```

Using #ImageMagick #montage #identify and #convert commands to make a #gradient out of image thumbnails sorted by average #sRGB #grey level:

```

montage -tile ${COLUMNS}x${ROWS} -geometry ${TILEWIDTH}x${TILEHEIGHT}+0+0 $( identify -colorspace RGB -format "%[fx:mean] %[filename]\n" in-*.png | sort -nr | cut -d\ -f 2 ) out.png &&

convert tmp.png -colorspace RGB -geometry ${WIDTH}x${HEIGHT} -colorspace sRGB out.png

```

I didn't yet figure out how to get the #gamma-correct colour space conversion to happen inside the montage's own rescaling, so I render at natural size and #downscale with convert afterwards.

The last image is the good result, the other two are gamma-incorrect, thus they appear too dark on screen (and presumably print too).

#fractals #graphics #monochrome #art

An excerpt from the parameter plane of this formula iterated in a loop (p = 2):

````

z := z^p + c

z := (|x| - i y)^p + c

z := (x - i |y|)^p + c

```

got sRGB gamma-correct scaling working in et, is a bit blurry because it uses mipmaps instead of more advanced (slower) algorithms like GIMP does, but the brightness is good.

before today's coding, the output in the et window was too dark (saved PNGs were brighter when downscaled by GIMP)

key things were: GL_SRGB8_ALPHA8 instead of GL_RGBA in texture specification; glEnable(GL_FRAMEBUFFER_SRGB) to do gamma-correct blending, and manual linear->sRGB in the final "display texture to screen" fragment shader because GtkGLArea does not expose a way to get an sRGB default framebuffer (yet; I filed a ticket)

#raytracing #mandelbulb #fragmentarium #threedee #fractals

I added light sampling to Raymond: for diffuse opaque surfaces it is vastly more efficient (less noise for given rendering time) than random sampling, at the cost of double the number of rays to trace (an additional one from each surface hit directly towards a light).

Not so beneficial for shiny opaque surfaces in one test. And it breaks rendering of transparent objects (refractive caustics disappear).

https://code.mathr.co.uk/raymond/commitdiff/636d2fc5dc19dbbe0c4c657f63d1f2271f7d6877#patch9

#autostereogram for #crosseyed viewing

depth map exported from #fragmentarium (one of the examples that comes with it)

horizontally repeating fractal texture made with #fractorium (modulusx final transform).

combined with homemade software. final image had autolevels applied to brighten it up before downscaling to 1920x1080@100dpi

I think this one turned out ok despite the depth discontinuities.

#autostereogram for #crosseyed viewing

#depth map exported to #exr from my "raymond" #raytracing thingy implemented in #glsl inside #fragmentarium , converted to #pfm using #gimp . EXR data must be in [0..1] for GIMP to understand it (otherwise it clips, not sure if it's clipped by FragM or GIMP). Not sure if sRGB non-linear response curve is mangling my data.

#fabric texture from a photo I took, cropped into a narrow vertical strip and made #seamless in #gimp

depth and texture combined with #homemade #software . took many iterations to get something that didn't make my eyes hurt too much. depth #discontinuity is jarring, too-small texture detail is distracting.

Refs:

- http://paulbourke.net/dataformats/pbmhdr/ for PFM file format (like PGM/PPM but float32 data)

#howto render a vertical strip that repeats horizontally in #fractorium (possibly also other #flame #fractals software like #apophysis or #chaotica ). possible use case: texture for #autostereogram generation.

0. start with some flame

1. add a Final transform with linear variation weight 0 and modulusx weight 1. its affine transform should be reset to identity.

2. set flame Width to 256px, and Scale to 128.0 (presumably half the width works in all cases).

3. make sure camera rotation and offset are 0.0

4. render!

Problems:

- a small seam is still visible in Firefox when zooming in, possible workaround is to render bigger, tile in #imagemagick #montage , then downscale and crop, to make the seam as (subpixel) small as desired

- "overlaps" in the fractal structure, but I don't care about that (yet)

Example:

I got #interior checking working for the #BurningShip , based on Xavier Buff's method for the Mandelbrot set presented by Arnaud Cheritat: https://www.math.univ-toulouse.fr/~cheritat/wiki-draw/index.php/Mandelbrot_set#The_idea

Replace `der` by the Jacobian $L$ w.r.t. $(x_1, y_1)$. Replace `squared_modulus(der)` with $|\det{L}|$. Arbitrarily use the pixel spacing for `eps`.

Should be straightforward to generalize the idea for other formulas.

The red zone of unknown is troubling - I wonder what is really going on in there.

got centred pattern fill working

print at 180dpi (A4) and view cross-eyed from about 7 inches

texture is based on https://rdex.mathr.co.uk/kiblix/texture/1324 #reactiondiffusion