> 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.
Oh, the page has changed since I posted the link. Here's the image that was on the page. (BBC credited it to Reuters).
I fixed #Bolsonaro 's mask.
Original image credit: Reuters via BBC https://www.bbc.co.uk/news/world-latin-america-53319517
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
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 #PrimeNumbers 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.
Trying to debug why shallow zooms in #KF 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.
#fractal #zoom #video calculated in #KF (515 keyframes forming an #ExponentialMap) 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 #CPlusPlus using #OpenGL #GLSL #shaders to colour the raw iteration data, wasn't hard to modify my earlier flat keyframe interpolator to work with exponential map slices. https://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).
My highly over-engineered extravagant framework of shaders including each other multiple times with different things defined (to emulate C++ templates with #GLSL function overloading without polymorphism) takes significantly longer to link the #shader than it does to render the #animation.
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.
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 https://en.wikipedia.org/wiki/Median_cut
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 https://en.wikipedia.org/wiki/Akaike_information_criterion 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.
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.
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).
making art with maths and algorithms
Welcome to post.lurk.org, an instance for discussions around cultural freedom, experimental, new media art, net and computational culture, and things like that.