Seems there is visible at the moment! Not sure I'll get to see it, 4am is a bit early/late.

theregister.com/2020/07/11/neo

> If you're in the northern hemisphere, and gazing up at the right moment – around 4am local time, July 10 to 15, looking northeast; and potentially an hour after sunset, July 14 to 23, looking northwest – you should catch a glimpse of the comet, C/2020 F3 NEOWISE. And local time really does mean the time wherever you are.

COVID 

Oh, the page has changed since I posted the link. Here's the image that was on the page. (BBC credited it to Reuters).

Show thread

Number of partitions of n into distinct parts >= 4; a(61) = 2021. PPM export rendered as a byte string. Not sure about the colour scheme. This one is stretched vertically more at the top (small parts) than the bottom (big parts) for aesthetic reasons.

Show thread

Number of partitions of n into distinct parts >= 4; pictured: a(47) = 447.

No gaps this time. Scanlines are doubled to get a better aspect ratio.

Will probably try to do the full a(61) = 2021 as high resolution (vector) graphics for the final image, these textures are starting to look pretty nice

Show thread

Number of partitions of n into distinct parts >= 4. a(61) = 2021; pictured: a(36) = 120

Show thread

I worked a bit on some ideas for a 2021 , raiding the Online Encyclopedia of Integer Sequences for inspiration.

Implemented the basic algorithm of one so far: the sum of all the parts of all the partitions of 43 into 9 primes is 2021. (There are 47 partitions, 2021 is the product of two adjacent 43 * 47). Making it prettier is a task for later.

```
python -m SimpleHTTPServer 8089
```
In UserLAnd seems to work fine in Chrome on the same tablet. Tested with Barry compiled from C source on the tablet.

Show thread

Trying to debug why shallow zooms in and/or disabling series approximation causes weird artifacts where the directional analytic distance estimate used for fake lighting effects ("slope colouring") doesn't line up between successive frames when rendering exponential maps, causing bad seams.

At deep zooms with series approximation, Mandelbrot set is fine, but other fractals are still buggy (I tested Burning Ship and Buffalo).

Today I implemented analytic DE for the hybrid fractal formula editor using dual numbers, and it has no problems whatsoever.

My current temptation is to delete most of the old formulas (given that they are at least partially broken) and replace them with example settings for the hybrid editor. Will have to benchmark this carefully in case it's too much slower.

But I need to fix the Mandelbrot set implementation, as using it without series approximation is much slower.

archive.org/details/kf-exp-map

calculated in (515 keyframes forming an ) in 66mins wall clock time, then assembled and encoded into a 3min video in 12mins wall clock time. Should be a part of the next major KF release come September time or so.

I implemented the video assembler in using to colour the raw iteration data, wasn't hard to modify my earlier flat keyframe interpolator to work with exponential map slices. mathr.co.uk/zoom

The colouring is based on directional distance estimate - close to the fractal is black, with rainbow tinges surrounding desaturating to white far from the fractal.

Magnet Mandelbulb (hopefully correct this time).

Looks much less interesting, and is much harder to render (needed to reduce DE multiplier and increase subframe count to get it to look acceptable).

Show thread

set mashed up with algebra (a la ) rendered with in fork of

My highly over-engineered extravagant framework of shaders including each other multiple times with different things defined (to emulate C++ templates with function overloading without polymorphism) takes significantly longer to link the than it does to render the .

First attempts with typos gave 100k lines of cascaded errors in the shader info log, which which the Qt GUI list widget was Not Happy At All. Luckily the log went to stdout too, so I could pipe to a file and see the start where I missed a return statement or two.

current progress, 4 colour conversion in GIMP, then exported a layer for each colour, then potrace command line for each layer and assembled the output into a single SVG with a bash script.

Show thread

Today this project is morphing into a generalized "make nice lo-colour/flat/line art from images" thing.

Two photos that my algorithms (currently a modified median cut that splits the largest group each time, where size is measured by the product of bounding box volume and pixel count) struggle with at the moment:

- the left image has large flat areas of almost same colour, and somehow my code dithers the top half in 3 colours instead of a nice clean split with 2 colours

- the right image has lots of greens and some "obvious" bright red, but limited to 8 colours my algorithms just give greens, no red.

GIMP does much better for both images, so next I'll look at how it does it.

continous coupled cellular automaton in OpengGL/GLSL exported to full colour RGB24 PPM image, with edge detection

median cut in C exporting each of the colours to its own black on white PGM image (this one had 5 colours)

potrace from bi-level bitmap to monochrome vector SVG image, one per colour

geany text edited the 5x SVGs into one SVG document with some pattern fill defs, changed the fill of each layer to one of the patterns, added stroke.

inkscape converted to PDF

okular displayed PDF

gimp took screenshot

TODO: shell script to automate it
TODO: make more patterns to fill with

Implemented median cut colour quantization as described at en.wikipedia.org/wiki/Median_c

The only non-straightforward part was needing to split at the boundary between median and next value, rather than (potentially) in the middle of a joint median region, to avoid weird artifacts where different parts of the image had different colours.

Hardcoded to 8 colours for now, not sure how to do optimal palette size choice with this method. Maybe en.wikipedia.org/wiki/Akaike_i or similar could work. But I'd need to redo the code structure, currently it's simply recursive (binary splitting, depth 3) and I'd need it to be iterative with a set of blocks to be able to make the decisions about when to stop splitting.

Show thread

Hmm it's very sensitive, these are all with the same input, only thing changing is the pseudo-random number generator seed... various numbers of colours are chosen as optimal, ranging from 2 to 11.

Probably I should minimize over some randoms in an innerer loop instead of outside the whole process.

Show thread

Worked (almost) first try! (after fixing compilation errors, one stupid typo in a variable name, and having to set ulimit -s unlimited in my shell because I have Big arrays on the stack).

Show thread

Revisiting my coupled continuous cellular automata project from a few years ago, now with a GPU that doesn't overheat.

Seems this morning I prefer the ones with "incorrect" grid artifacts (strongly horizontal/vertical/45deg aligned edges).

Show more
post.lurk.org

Welcome to post.lurk.org, an instance for discussions around cultural freedom, experimental, new media art, net and computational culture, and things like that.