claude @mathr@post.lurk.org

Geometric zooming occurs about Feigenbaum points:

$$
c_{n+1} - c = a (c_n - c)
$$

Concretely with $3$ successive points $c_k$
$$
a = \frac{c_2 - c}{c_1 - c} = \frac{c_1 - c}{c_0 - c}
$$

Simple algebra gives:
$$
(c_2 - c) (c_0 - c) = (c_1 - c)^2
$$
which is linear in $c$ (the $c^2$ terms cancel):
$$
c = \frac{c_1^2 - c_2 c_0}{2 c_1 - c_2 - c_0}
$$

Substitute $c$ into the equation for $a$ to get its value.

https://mathr.co.uk/zoomasm/#zoomasm-2-0 #zoomasm 2.0 released. zoomasm is an assembler for 2D (and now also 360) zoom videos from exponential map keyframes in EXR format to video files via OpenGL shaders for colouring raw iteration data and FFmpeg for video encoding.

The 360 video metadata need to be injected later, with Google's spatial media tool, I haven't figured out yet if ffmpeg command line can do it...

https://mathr.co.uk/kf/kf.html#kf-2.15.1.6
https://mathr.co.uk/kf/kf.html#kf-2.14.10.7

Two bugfix releases of #KF in current branch and stable branch: turns out switching #MinGW from #Win32 to #POSIX #threading model had some unforeseen consequences (aka bugs, one of which was "zooming out sometimes resets zoom to infinity or zero" which broke interactive use), so I reverted those changes.

#KallesFraktaler2 is fast #fractal #DeepZoom #FreeSoftware for #MandelbrotSet #BurningShip etc

To get a flavour of what GridFlow is like, check out its help patches:

https://gridflow.ca/help/

It had an elaborate auto-layout system achieved by overriding Pd internals at runtime, e.g. comments now have an inlet so can be connected from things, which move them around to fit properly. Also a thing to load and screenshot all the documentation in one go. But this fancy stuff is a bit fragile and has bitrotted to some degree...

GridFlow is abandonware, I did make some attempts to get it working again relatively recently:

https://mathr.co.uk/gridflow/patches/

(patch series as opposed to a repository as I misplaced my SVN credentials, and different git-svn clones can have divergent history depending on svn.authors information)

There would probably need to be a primop to "freeze" an array signal into a memory buffer, for use in feedback (required to delay the signal) or for efficiency (for example between successive spatial convolutions in a separable multidimensional blur). On the other hand, it would be beneficial to combine chains of operations into a single OpenCL kernel, so less video memory (and memory bandwidth) is needed. Automatic freezing would be nice, but is probably a hard problem.

Project idea: mashup of #FAuSt (signal processing block diagram algebra) and #GridFlow (multidimensional array processing for #PureData inspired by #APL etc) compiled via #OpenCL to run on #GPU.

https://gridflow.ca/
https://faust.grame.fr/

https://mathr.co.uk/dezoomber
a #daily short #fractal #zoom #video for the month of #dezoomber

videos created with a slightly patched rodney (modified to save raw keyframe data to EXR files and palette specification as GLSL) and zoomasm (modified to truncate output video based on video content), orchestrated by a bash shell script

@PureData

Saw an exciting announcement:
https://lists.puredata.info/pipermail/pd-announce/2020-12/002760.html

> I would like to share my recent work PdWebParty which is a web app that allows you to run Pd patches in a web browser and share them by using a web link. As the name implies, it is inspired by PdDroidParty and PdParty.

> Currently, the app only supports Bang(bng), Toggle(tgl), Canvas(cnv), and Comment but other objects will be added soon.

> You can try the app from https://pdwebparty.herokuapp.com/

> For more information, visit https://github.com/cuinjune/PdWebParty

> -- Zack Lee

@PureData my Gem in web browser experiment seems limited to fixed function pipeline only: for shaders, unless you are lucky, you will need to rewrite them (and the supporting patch) to be compliant with OpenGL ES / WebGL, because as far as I can tell so far Regal does not have a shader compatibility layer, so things like gl_TexCoord are missing :(

@PureData
Got #Gem working in the #WebBrowser again. Had to patch #GLU to make it use #Regal, then some patching of Gem to make the #OpenGL 1.0 and 1.1 functions go via Regal (I haven't figured out why I need to do that - something RegalGLEW related maybe - didn't need it for GLU).

Instructions at https://mathr.co.uk/empd/#build-gem work on Debian Buster (current stable) and Debian Bullseye (current testing), with scripts to set up a Debian chroot if you have a different system.

The example at https://mathr.co.uk/empd/examples/gemtest/ should be a colour changing spinning cube with simple (Regal-emulated fixed function pipeline) 3D lighting / shading, some browsers may need user interaction with the page to make it work due to Google policies...

https://pastie.iem.at/ is a #PasteBin that supports #PureData #patch as a language type. Paste your patch contents and have it visualized on the resulting web page, with the text also there to download to your #Pd.

@PureData

@PureData

I spent some time recently cleaning up my #EmPd stuff for compiling #LibPd #Pd #PureData with #Emscripten so you can run audio patches in the #WebBrowser (without pd-gui support, but you can build custom GUIs to make interactive things).

Instructions at
https://mathr.co.uk/empd/

Currently working on trying to support #Gem via Emscripten's #Regal port, but it's frustrating because Gem's `./configure` takes forever and I'm not skilled at #autoconf stuff to know how to fix it when weird things happen.

I heard #PurrData has a browser thing now too, maybe I should see how they do it. Don't know if they have Gem there.

worked a bit more, made a regular non-browser based version:
```
git clone https://code.mathr.co.uk/rodney.git
cd rodney
make rodney
./rodney
```
(note: still very CPU heavy, add --aa 1 to make it faster but uglier)

tested briefly on Debian Buster x86_64, there may still be memory leaks, deadlocks, or other badness...

worked a bit on my browser-based autonomous fractal explorer bot:
https://mathr.co.uk/rodney/latest/
(note: very CPU heavy, add ?aa=1 to make it faster but uglier)

https://mathr.co.uk/kf/kf.html#kf-2.15.1.5
kf-2.15.1.5 released!

- fix long double rendering for hybrid formulas with abs
- fix typos breaking OpenCL floatexp bailout checks
- fix guessing for OpenCL floatexp
- fix endless reference loop in OpenCL
- merge changes from kf-2.14.10.6

https://mathr.co.uk/kf/kf.html#kf-2.14.10.6
kf-2.14.10.6 released!

- fix long double rendering for formulas with abs
- fix floatexp rendering for fractional bailout norm power
- fix some float conversion warnings and potential problems
- make prepare script modular (second argument determines libraries to build, default is all libraries)
- patch OpenEXR to try to fix issues with non-ASCII paths on Windows

#kf aka #KallesFraktaler #KallesFraktaler2 is #fast #DeepZoom #FreeSoftware for #EscapeTime #fractal like #MandelbrotSet #BurningShip etc. For Windows but works in Wine and is cross-compiled from Linux using MinGW.

Managed to fractalize a variant based on a sheared stack of toruses (such that the ends join up into a helix). Still has assumptions about the rise per revolution being small, but it turned out well. Rendered with "Raymond", my physically-inspired raytracer, using a material similar to water but more extreme in both index of refraction and absorption coefficients.

Render at 3840x2160 with 256 subframes took about 1.5 hours. Exported from FragM in EXR format, colour balance adjusted in Darktable, cropped/framed in GNU IMP.

If you need a lot of harmonics, it can be done in parallel (SIMD? FPGA?) by using the relations:

$$
T_{2n} = T_n^2 - 1
T_{2n+1} = T_{n+1} T_n - x
$$

For the second kind, I think you can use these ones:

$$
U_{2n-1} = 2 T_n U_{n-1}
U_{2n} = T_{2n} + x U_{2n-1}
$$

(hope I didn't make any mistakes working that out)

Implemented bandlimited PWM via difference of two bandlimited saws (constructed by additive synthesis):

```
vec2 saw(float t)
{
float s = sin(t);
float c = cos(t);
float su = 1.0;
float sv = 2.0 * c;
float cu = 1.0;
float cv = c;
float sgn = 1.0;
int k = 1;
float sum = 0.0;
float dsum = 0.0;
while (k <= 16)
{
float term = sgn * su / float(k++);
float dterm = sgn * cu;
sum += term;
dsum += dterm;
sgn = -sgn;
float sw = 2.0 * c * sv - su; su = sv; sv = sw;
float cw = 2.0 * c * cv - cu; cu = cv; cv = cw;
}
return vec2(s * sum, dsum);
}
```

(This computes the derivative too for waveform plotting purposes.)