#iterati — Public Fediverse posts

It was twenty years ago today
Sam L Jackson fought the snakes in air
They've been going in and out of memes
Guess they're funny if you're in your teens
So may I just remind you of
The act you've known for all these years
Monty Python's "Hovercraft full of eels".

#snakesonaplane #myhovercraftisfullofeels

#digitaldoodle #meander #matopeli #creepycrawly #wiggle #slither #pythoncode #opengl #algorithmicart #algorist #creativecoding #artxcode #computerart #ittaide #kuavataide #iterati

I've been playing with a very simple approach to meandering paths. I'm not sure if I'm getting anywhere with these, but I thought I'd post some of the tests so far.

The problem with the 2D idea is that the paths will easily wander off the screen. So I thought I'd put them on a spherical surface to contain them. It turned out this isn't quite trivial, and I had to rethink what directions and turns actually mean there. It all came down to the Non-Euclidean nature of the sphere. A straight-line direction there means a great circle, but no two great circles can be parallel. So directions and positions are rather closely linked. This is in contrast to Euclidean geometry, where you can go from any point into any direction.

#meander #matopeli #creepycrawly #wiggle #slither #pythoncode #opengl #algorithmicart #algorist #creativecoding #artxcode #computerart #ittaide #kuavataide #iterati

More wriggling motions in the plasma-globe-inspired demo. I also added periodic resets to further mess things up.

#plasmaglobe #plasma #particlesimulation #pythoncode #opengl #vertexshader #algorithmicart #algorist #creativecoding #artxcode #computerart #ittaide #kuavataide #iterati

It's been quiet on the demo front as my musician side has recently taken over. This slow return to musicianship started last summer, with the new twist of using the Karelian language. I've also put some of my old and new demos to work for the music videos. Here's the latest piece by me and Noira, you'll find a couple more on the same Salixvelox channel:

https://youtu.be/XI9XJKDMd3k

#karelianlanguage #karelianproper #southkarelian #karjalankieli #karjalankielieläy #varzinkarjala #suvikarjala #opengl #pythoncode #algorithmicart #algorist #creativecoding #artxcode #computerart #ittaide #kuavataide #iterati

From a pile of shit, new life grows. Conway's Game of Life running independently in the 3 colour channels in 64x64 cells with wrap-around topology.

Not much new code here, just added image loading capability to my old pile-up demo of 2D cellular automata.

#cellularautomaton #gameoflife #conwaysgameoflife #pixelart #voxelart #blockart #3dgraphics #opengl #pythoncode #numpy #algorithmicart #algorist #creativecoding #artxcode #computerart #ittaide #kuavataide #iterati

Rule/Yule 30 cellular automaton with a "band-pass" filter every few iterations. Done in the Bash shell using bitwise math, so each row/state is a single number of 63 bits.

#cellularautomata #cellularautomaton #rule30 #bitwiseoperators #textmode #textmodeart #oldskool #retrocomputing #unixshell #shellprogramming #xterm #joulu6 #xmastree #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Rule/Yule 30 cellular automaton with a "band-pass" filter every few iterations. Done in the Bash shell using bitwise math, so each row/state is a single number of 63 bits.

#cellularautomata #cellularautomaton #rule30 #bitwiseoperators #textmode #textmodeart #oldskool #retrocomputing #unixshell #shellprogramming #xterm #joulu6 #xmastree #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Rule/Yule 30 cellular automaton with a "band-pass" filter every few iterations. Done in the Bash shell using bitwise math, so each row/state is a single number of 63 bits.

#cellularautomata #cellularautomaton #rule30 #bitwiseoperators #textmode #textmodeart #oldskool #retrocomputing #unixshell #shellprogramming #xterm #joulu6 #xmastree #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Sierpinski triangles on an icosahedron, inspired by Ghee Beom Kim

#sierpinskitriangle #icosahedron #geometricart #fractal #fractalart #iteratedfunctionsystem #3dgraphics #raymarching #pythoncode #numpy #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Sierpinski triangles on an icosahedron, inspired by Ghee Beom Kim

#sierpinskitriangle #icosahedron #geometricart #fractal #fractalart #iteratedfunctionsystem #3dgraphics #raymarching #pythoncode #numpy #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Sierpinski triangles on an icosahedron, inspired by Ghee Beom Kim

#sierpinskitriangle #icosahedron #geometricart #fractal #fractalart #iteratedfunctionsystem #3dgraphics #raymarching #pythoncode #numpy #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Another blow-up view of the Apollonian spheres, now dropping on a concave surface to gather all the jetsam together. This is what I had in mind when writing the first drop demo, and the model just needed a bit of refinement for the differently sized balls: properly scaled masses and elastic factors, as well as proper handling of these quantities in each pair collision.

As a recovering science teacher, it's fun to see such physics in action: a simple, linear elastic force is all it takes to keep each body in its place. Well, at least approximately; I've included a basic drag term to help things settle, but it seems it would take a while, as the tiniest balls are easily thrown around by the larger masses.

#apollonianspheres #apolloniangasket #particlesimulation #elasticcollision #hookeslaw #3dgraphics #pythoncode #numpy #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

With 2D Apollonian gaskets, it's easy to build arbitrary initial configurations. Simply picking 3 random points means you have to solve for 3 radii to make a kissing setup. Since there are exactly 3 distances between the points, this makes a basic linear system. But not so in 3D: you have 4 points and 4 radii, but 6 different distances, so a linear solution won't cut it. You could start with 3 kissing spheres using the 2D logic, but then you can't put the 4th point just anywhere.

I didn't bother with the messy quadratic system, because there's an easier way: take the symmetric tetrahedral config and deform it using an inversion. Yep, the same tool that's already the bread and butter of gasket-weaving. What's more, we can build the symmetric gasket first and then deform the whole thing. Inversion preserves spheres as spheres and maintains their kissing relations, it doesn't care how many there are.

In other words, the order doesn't matter with inversions. I've used this trick years ago in some 2D inversion demos to simplify things, and this 3D also benefits hugely from it. Besides the problem of initial config, 3D gaskets also have a speed issue due to deduplication (explained in an earlier post). The inversions are very fast as they can be parallelized, and this also applies to the deformations. So it's nice that we need not rebuild the gasket again for every config, we can just deform the same thing again.

#apollonianspheres #apolloniangasket #gasketweaving #iteratedfunctionsystem #inversion #sphereinversion #geometricart #3dgraphics #digitalsculpture #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

With 2D Apollonian gaskets, it's easy to build arbitrary initial configurations. Simply picking 3 random points means you have to solve for 3 radii to make a kissing setup. Since there are exactly 3 distances between the points, this makes a basic linear system. But not so in 3D: you have 4 points and 4 radii, but 6 different distances, so a linear solution won't cut it. You could start with 3 kissing spheres using the 2D logic, but then you can't put the 4th point just anywhere.

I didn't bother with the messy quadratic system, because there's an easier way: take the symmetric tetrahedral config and deform it using an inversion. Yep, the same tool that's already the bread and butter of gasket-weaving. What's more, we can build the symmetric gasket first and then deform the whole thing. Inversion preserves spheres as spheres and maintains their kissing relations, it doesn't care how many there are.

In other words, the order doesn't matter with inversions. I've used this trick years ago in some 2D inversion demos to simplify things, and this 3D also benefits hugely from it. Besides the problem of initial config, 3D gaskets also have a speed issue due to deduplication (explained in an earlier post). The inversions are very fast as they can be parallelized, and this also applies to the deformations. So it's nice that we need not rebuild the gasket again for every config, we can just deform the same thing again.

#apollonianspheres #apolloniangasket #gasketweaving #iteratedfunctionsystem #inversion #sphereinversion #geometricart #3dgraphics #digitalsculpture #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

With 2D Apollonian gaskets, it's easy to build arbitrary initial configurations. Simply picking 3 random points means you have to solve for 3 radii to make a kissing setup. Since there are exactly 3 distances between the points, this makes a basic linear system. But not so in 3D: you have 4 points and 4 radii, but 6 different distances, so a linear solution won't cut it. You could start with 3 kissing spheres using the 2D logic, but then you can't put the 4th point just anywhere.

I didn't bother with the messy quadratic system, because there's an easier way: take the symmetric tetrahedral config and deform it using an inversion. Yep, the same tool that's already the bread and butter of gasket-weaving. What's more, we can build the symmetric gasket first and then deform the whole thing. Inversion preserves spheres as spheres and maintains their kissing relations, it doesn't care how many there are.

In other words, the order doesn't matter with inversions. I've used this trick years ago in some 2D inversion demos to simplify things, and this 3D also benefits hugely from it. Besides the problem of initial config, 3D gaskets also have a speed issue due to deduplication (explained in an earlier post). The inversions are very fast as they can be parallelized, and this also applies to the deformations. So it's nice that we need not rebuild the gasket again for every config, we can just deform the same thing again.

#apollonianspheres #apolloniangasket #gasketweaving #iteratedfunctionsystem #inversion #sphereinversion #geometricart #3dgraphics #digitalsculpture #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Making Apollonian gaskets usually follows a key rule of iterated function systems: each iteration should make the thing smaller. With inversions, this means going from the outside to the inside of inverting circles.

However, it's possible to make valid gaskets using a lopsided configuration, where the initial circles are bunched up on one side. In that case, the first iteration has to make a larger circle to fill the opposite side. This means an inversion from the inside to outside. But we can also think of this as turning the inversion circle inside out.

This turns out nice both visually and conceptually. An inversion circle is essentially a curved mirror, and we can make a smooth transition from the convex to the concave by passing through the flat stage. I wasn't sure if this would work cleanly in this simple demo, since the flat mirror means a circle with infinite radius; fortunately, the finite time steps mean we can skip over the flat point.

As for IFS rules, the system as a whole is contractive, thanks to the other circles that are now more convex.

The second part gives another look at such initially lopsided gaskets.

#apolloniancircles #apolloniangasket #iteratedfunctionsystem #inversion #circleinversion #geometricart #fractal #fractalart #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Making Apollonian gaskets usually follows a key rule of iterated function systems: each iteration should make the thing smaller. With inversions, this means going from the outside to the inside of inverting circles.

However, it's possible to make valid gaskets using a lopsided configuration, where the initial circles are bunched up on one side. In that case, the first iteration has to make a larger circle to fill the opposite side. This means an inversion from the inside to outside. But we can also think of this as turning the inversion circle inside out.

This turns out nice both visually and conceptually. An inversion circle is essentially a curved mirror, and we can make a smooth transition from the convex to the concave by passing through the flat stage. I wasn't sure if this would work cleanly in this simple demo, since the flat mirror means a circle with infinite radius; fortunately, the finite time steps mean we can skip over the flat point.

As for IFS rules, the system as a whole is contractive, thanks to the other circles that are now more convex.

The second part gives another look at such initially lopsided gaskets.

#apolloniancircles #apolloniangasket #iteratedfunctionsystem #inversion #circleinversion #geometricart #fractal #fractalart #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Making Apollonian gaskets usually follows a key rule of iterated function systems: each iteration should make the thing smaller. With inversions, this means going from the outside to the inside of inverting circles.

However, it's possible to make valid gaskets using a lopsided configuration, where the initial circles are bunched up on one side. In that case, the first iteration has to make a larger circle to fill the opposite side. This means an inversion from the inside to outside. But we can also think of this as turning the inversion circle inside out.

This turns out nice both visually and conceptually. An inversion circle is essentially a curved mirror, and we can make a smooth transition from the convex to the concave by passing through the flat stage. I wasn't sure if this would work cleanly in this simple demo, since the flat mirror means a circle with infinite radius; fortunately, the finite time steps mean we can skip over the flat point.

As for IFS rules, the system as a whole is contractive, thanks to the other circles that are now more convex.

The second part gives another look at such initially lopsided gaskets.

#apolloniancircles #apolloniangasket #iteratedfunctionsystem #inversion #circleinversion #geometricart #fractal #fractalart #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Another look at Apollonian spheres, cutting out the top half and showing a few iteration steps.

#apollonianspheres #apolloniangasket #iteratedfunctionsystem #inversion #sphereinversion #geometricart #3dgraphics #digitalsculpture #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Another look at Apollonian spheres, cutting out the top half and showing a few iteration steps.

#apollonianspheres #apolloniangasket #iteratedfunctionsystem #inversion #sphereinversion #geometricart #3dgraphics #digitalsculpture #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Another look at Apollonian spheres, cutting out the top half and showing a few iteration steps.

#apollonianspheres #apolloniangasket #iteratedfunctionsystem #inversion #sphereinversion #geometricart #3dgraphics #digitalsculpture #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Taking my lastest Apollonian gasket code from 2D to 3D was quite straightforward in principle, though there were a few kinks in the road. A particular difference between 2D and 3D gaskets is that in 3D, the inversion spheres overlap, which can create duplicate spheres.

Viewing detailed 3D structures isn't trivial either. We can only really see in 2D, as one dimension is taken up by the ray of light. Looking from outside, I wouldn't guess this blob contains over 10k spheres, so I blew it up for this clip.

The sheer amount of balls is also heavy on the drawing side, so I used my low-poly "sprites" where each ball is drawn by a geometry shader from a single input point. The low-poly aspect is quite clear in the largest spheres, but I think it's OK for this math demo.

#apollonianspheres #apolloniangasket #iteratedfunctionsystem #inversion #sphereinversion #geometricart #3dgraphics #digitalsculpture #pythoncode #opengl #geometryshader #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Taking my lastest Apollonian gasket code from 2D to 3D was quite straightforward in principle, though there were a few kinks in the road. A particular difference between 2D and 3D gaskets is that in 3D, the inversion spheres overlap, which can create duplicate spheres.

Viewing detailed 3D structures isn't trivial either. We can only really see in 2D, as one dimension is taken up by the ray of light. Looking from outside, I wouldn't guess this blob contains over 10k spheres, so I blew it up for this clip.

The sheer amount of balls is also heavy on the drawing side, so I used my low-poly "sprites" where each ball is drawn by a geometry shader from a single input point. The low-poly aspect is quite clear in the largest spheres, but I think it's OK for this math demo.

#apollonianspheres #apolloniangasket #iteratedfunctionsystem #inversion #sphereinversion #geometricart #3dgraphics #digitalsculpture #pythoncode #opengl #geometryshader #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

As I keep studying the Apollonian gasket, I've now implemented the inversion approach on the CPU for finding the circle centres and radii. Now I can generate these arrays of eyes much faster, as the inversion is easier to parallelize. It's so fast that the bottleneck is now in the drawing stage.

The colours denote a kind of family tree of inversions: the 4 initial circles each have their own colour, and their inversion images retain the colour. The outer circle is not shown here, but its descendants show the colour that's distinct from the other 3.

I still needed something other than inversions for setting up the initial quartet, but I wanted find my own solution instead of relying on Descartes' theorem. The theorem actually comes in two parts: Rene's original theorem only deals with the radii, while the complex quadratic formula for finding the circle positions was only developed in the late 1990s.

Well, I found an alternative solution to the latter part, and it reduces to a pair of linear equations. It isn't particularly fast to compute, but I think it's easier to understand — it's basically junior high school math. In fact, it seems so basic that I can't be the first one to discover it.

#eyecandy #apolloniancircles #apolloniangasket #iteratedfunctionsystem #inversion #circleinversion #geometricart #fractal #fractalart #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

As I keep studying the Apollonian gasket, I've now implemented the inversion approach on the CPU for finding the circle centres and radii. Now I can generate these arrays of eyes much faster, as the inversion is easier to parallelize. It's so fast that the bottleneck is now in the drawing stage.

The colours denote a kind of family tree of inversions: the 4 initial circles each have their own colour, and their inversion images retain the colour. The outer circle is not shown here, but its descendants show the colour that's distinct from the other 3.

I still needed something other than inversions for setting up the initial quartet, but I wanted find my own solution instead of relying on Descartes' theorem. The theorem actually comes in two parts: Rene's original theorem only deals with the radii, while the complex quadratic formula for finding the circle positions was only developed in the late 1990s.

Well, I found an alternative solution to the latter part, and it reduces to a pair of linear equations. It isn't particularly fast to compute, but I think it's easier to understand — it's basically junior high school math. In fact, it seems so basic that I can't be the first one to discover it.

#eyecandy #apolloniancircles #apolloniangasket #iteratedfunctionsystem #inversion #circleinversion #geometricart #fractal #fractalart #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

2D circle inversion fractals on the spherical surface. This was a fun offshoot of my recent Apollonian endeavours, again using the Riemann sphere mapping to go from 3D to 2D for the iterations.

The inversion circle centres come from a tetrakis hexahedron and a triakis icosahedron, so the circles form approximations of a truncated octahedron and a truncated dodecahedron.

#apolloniancircles #apolloniangasket #inversion #circleinversion #riemannsphere #geometricart #fractal #fractalart #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

In the last post, I noted how the incremental iterates of the Apollonian gasket look like the output of an iterated function system. There's indeed such an IFS, and it's a system of circle inversions. It's how I've made a lot of fractal art over the years, but I've usually started directly with the inversion circles/spheres themselves.

Now that I've worked with the "classical" approach to the Apollonian gasket, I thought I'd translate a given Apollonian setup to the language of inversions. It was a fun little exercise and the math was surprisingly simple, just playing with vectors and solving linear equations. I then used my old inversion shaders from the late 2010s to show the results.

The first part shows it all together: the 3 largest coloured circles are the initial Apollonian circles, and the 4 inversion circles can be seen in the darkest grey in the background. (The initial Apollonian circles also include a 4th one, but here we can only see it as the perimeter of the coloured area.)

The second part uses a pointillist process, and it shows essentially the incremental iterates of the previous post. The inversion circles are not seen, but the Apollonian circles are all there as the empty space.

#apolloniancircles #apolloniangasket #iteratedfunctionsystem #inversion #circleinversion #geometricart #fractal #fractalart #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

The Apollonian gasket is a bit peculiar as an iterated system. The Nth stage of circles isn't generated solely by generation N-1, but all of the preceding generations. Alternatively, one might say that each circle also regenerates itself for the next level. Either way, it doesn't work like a typical IFS.

As I wonder how it all works, I'm showing you a couple of different views of the Apollonian iteration. The first part is just the regular progression. The second is the same, but only the newest generation of circles is shown. It looks a bit like a regular IFS as the iteration level increases.

The last two parts show a kind of graph view of the process, with the same structure seen through 2 different cameras. The balls and sticks are scaled in proportion to the circles they represent, and each child is connected to its parents. To avoid messing up the view completely, I've left out the outer circle that encompasses all the others, so a lot of circles show only 2 parents.

#apolloniancircles #apolloniangasket #iteratedfunctionsystem #geometricart #fractal #fractalart #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

The set of polyhedra that can be converted into Apollonian gaskets via sphere-plane mapping is quite limited. The face polygons should be regular, the edge midpoints should all lie on the same sphere, and the vertices should be 3-fold. There are some Platonic solids that work, and I've showed all of these earlier. It turns out that Archimedean solids with 3-fold vertices work too. So here's a truncated octahedron, also showing a progressive view of the gasket iteration.

#apolloniancircles #apolloniangasket #riemannsphere #archimedeansolid #truncatedoctahedron #geometricart #fractal #fractalart #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Another style for regular 2D Apollonian gaskets

#apolloniancircles #apolloniangasket #relief #emblem #geometricart #fractal #fractalart #raymarching #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Another look at the Apollonian gasket. This shows that the process doesn't use simple inversion, since that would distort the image within each disc.

#apolloniancircles #apolloniangasket #geometricart #fractal #fractalart #biblicallyaccurateangels #weirdart #creepyart #horrorart #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Back to basics: I made an Apollonian gasket generator based on Descartes' theorem, as explained on Wikipedia. The method involves some nontrivial details on the choice of +/- signs, which I had to figure out on my own.

The result looks a lot like some of the inversion fractals I've done over the years, and they are certainly related. But writing this classical method on the CPU side was an attempt to do and learn something different. Using 6 iterations was a compromise between detail and rendering speed — at 5 or so FPS this wasn't quite realtime, though I guess it can be optimized further.

#apolloniancircles #circleinversion #indraspearls #geometricart #fractal #fractalart #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Testing the Gosper curve in my variable iteration halftoning setup. So far I've only used the Hilbert curve this way, and things get a bit coarser with the Gosper, so it was harder to find images that make nice results. So here we are with the old Venus again.

The number of points multiplies by 4 for Hilbert and 7 for Gosper on each step, so the latter has to get by with fewer iterations for a sensible resolution. Here we have 6 iterations for 6 grey levels.

#halftoneart #gospercurve #planefillingcurve #spacefillingcurve #singlelinedrawing #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Testing the Gosper curve in my variable iteration halftoning setup. So far I've only used the Hilbert curve this way, and things get a bit coarser with the Gosper, so it was harder to find images that make nice results. So here we are with the old Venus again.

The number of points multiplies by 4 for Hilbert and 7 for Gosper on each step, so the latter has to get by with fewer iterations for a sensible resolution. Here we have 6 iterations for 6 grey levels.

#halftoneart #gospercurve #planefillingcurve #spacefillingcurve #singlelinedrawing #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Testing the Gosper curve in my variable iteration halftoning setup. So far I've only used the Hilbert curve this way, and things get a bit coarser with the Gosper, so it was harder to find images that make nice results. So here we are with the old Venus again.

The number of points multiplies by 4 for Hilbert and 7 for Gosper on each step, so the latter has to get by with fewer iterations for a sensible resolution. Here we have 6 iterations for 6 grey levels.

#halftoneart #gospercurve #planefillingcurve #spacefillingcurve #singlelinedrawing #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Testing the Gosper curve in my variable iteration halftoning setup. So far I've only used the Hilbert curve this way, and things get a bit coarser with the Gosper, so it was harder to find images that make nice results. So here we are with the old Venus again.

The number of points multiplies by 4 for Hilbert and 7 for Gosper on each step, so the latter has to get by with fewer iterations for a sensible resolution. Here we have 6 iterations for 6 grey levels.

#halftoneart #gospercurve #planefillingcurve #spacefillingcurve #singlelinedrawing #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Testing the Gosper curve in my variable iteration halftoning setup. So far I've only used the Hilbert curve this way, and things get a bit coarser with the Gosper, so it was harder to find images that make nice results. So here we are with the old Venus again.

The number of points multiplies by 4 for Hilbert and 7 for Gosper on each step, so the latter has to get by with fewer iterations for a sensible resolution. Here we have 6 iterations for 6 grey levels.

#halftoneart #gospercurve #planefillingcurve #spacefillingcurve #singlelinedrawing #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

In the last post, Tis Veugen suggested dithering with the Gosper curve. At first I thought this doesn't make sense, since the curve lives on a hexagonal lattice, while dithering is generally done at the native pixel level, which means a square lattice. But as I thought about this further, it started to look like a fun challenge. Besides, the square grid hasn't always been the native way to organize pixels; for example, some old CRTs also used a hex lattice.

So I was really just making up excuses for the extra work. First I had to set up interpolated sampling, which would come for free in OpenGL, but now I was working on the CPU. The Gosper curve was also new to me, and I implemented it in my own way from first principles using IFS ideas, like I'd done earlier with the Peano curve.

For comparison, here's also a version with the boustrophedon curve on a hexagon, since I already had that curve function in my toolbox. Finally there's also the raw Gosper curve, though a smaller version to give a clearer idea.

#dithering #halftoneart #raster #pixelart #gospercurve #planefillingcurve #spacefillingcurve #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

The previous demo made me dig deeper into dithering algorithms. It's something I should have done years ago, as I've been using simple random dithering now and then, and I hadn't even thought of gamma correction. One algorithm in particular caught my eye: Riemersma dithering, which uses the Hilbert curve. Compared to the usual matrices for error diffusion, the curve approach seemed easier to implement in some ways, as it has fewer edge issues.

More interestingly, it struck a chord with my earlier experiments with space-filling curves in image processing. So it was a kind of familiar territory, but it also seemed esoteric enough that I could imagine making some new discoveries. For example, play with other plane-filling curves besides the Hilbert.

The first image uses the boustrophedon curve, which makes the vertical wave patterns I recall from a number of non-dithering demos. The second curve is what I call the diagstrophedon, a diagonal zig-zag starting from the top left corner, and I think its wavy artefacts make a nice match for Venus's hair.

Then in image 3 we have Hilbert, which doesn't seem to make any particular artefacts, and I guess that's a good thing for dithering. Finally 4 uses the Peano curve, which makes some fun wiggles in light areas.

#dithering #riemersmadithering #stippling #halftoneart #raster #pixelart #hilbertcurve #peanocurve #planefillingcurve #spacefillingcurve #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

The previous demo made me dig deeper into dithering algorithms. It's something I should have done years ago, as I've been using simple random dithering now and then, and I hadn't even thought of gamma correction. One algorithm in particular caught my eye: Riemersma dithering, which uses the Hilbert curve. Compared to the usual matrices for error diffusion, the curve approach seemed easier to implement in some ways, as it has fewer edge issues.

More interestingly, it struck a chord with my earlier experiments with space-filling curves in image processing. So it was a kind of familiar territory, but it also seemed esoteric enough that I could imagine making some new discoveries. For example, play with other plane-filling curves besides the Hilbert.

The first image uses the boustrophedon curve, which makes the vertical wave patterns I recall from a number of non-dithering demos. The second curve is what I call the diagstrophedon, a diagonal zig-zag starting from the top left corner, and I think its wavy artefacts make a nice match for Venus's hair.

Then in image 3 we have Hilbert, which doesn't seem to make any particular artefacts, and I guess that's a good thing for dithering. Finally 4 uses the Peano curve, which makes some fun wiggles in light areas.

#dithering #riemersmadithering #stippling #halftoneart #raster #pixelart #hilbertcurve #peanocurve #planefillingcurve #spacefillingcurve #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

The previous demo made me dig deeper into dithering algorithms. It's something I should have done years ago, as I've been using simple random dithering now and then, and I hadn't even thought of gamma correction. One algorithm in particular caught my eye: Riemersma dithering, which uses the Hilbert curve. Compared to the usual matrices for error diffusion, the curve approach seemed easier to implement in some ways, as it has fewer edge issues.

More interestingly, it struck a chord with my earlier experiments with space-filling curves in image processing. So it was a kind of familiar territory, but it also seemed esoteric enough that I could imagine making some new discoveries. For example, play with other plane-filling curves besides the Hilbert.

The first image uses the boustrophedon curve, which makes the vertical wave patterns I recall from a number of non-dithering demos. The second curve is what I call the diagstrophedon, a diagonal zig-zag starting from the top left corner, and I think its wavy artefacts make a nice match for Venus's hair.

Then in image 3 we have Hilbert, which doesn't seem to make any particular artefacts, and I guess that's a good thing for dithering. Finally 4 uses the Peano curve, which makes some fun wiggles in light areas.

#dithering #riemersmadithering #stippling #halftoneart #raster #pixelart #hilbertcurve #peanocurve #planefillingcurve #spacefillingcurve #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

The previous demo made me dig deeper into dithering algorithms. It's something I should have done years ago, as I've been using simple random dithering now and then, and I hadn't even thought of gamma correction. One algorithm in particular caught my eye: Riemersma dithering, which uses the Hilbert curve. Compared to the usual matrices for error diffusion, the curve approach seemed easier to implement in some ways, as it has fewer edge issues.

More interestingly, it struck a chord with my earlier experiments with space-filling curves in image processing. So it was a kind of familiar territory, but it also seemed esoteric enough that I could imagine making some new discoveries. For example, play with other plane-filling curves besides the Hilbert.

The first image uses the boustrophedon curve, which makes the vertical wave patterns I recall from a number of non-dithering demos. The second curve is what I call the diagstrophedon, a diagonal zig-zag starting from the top left corner, and I think its wavy artefacts make a nice match for Venus's hair.

Then in image 3 we have Hilbert, which doesn't seem to make any particular artefacts, and I guess that's a good thing for dithering. Finally 4 uses the Peano curve, which makes some fun wiggles in light areas.

#dithering #riemersmadithering #stippling #halftoneart #raster #pixelart #hilbertcurve #peanocurve #planefillingcurve #spacefillingcurve #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

The previous demo made me dig deeper into dithering algorithms. It's something I should have done years ago, as I've been using simple random dithering now and then, and I hadn't even thought of gamma correction. One algorithm in particular caught my eye: Riemersma dithering, which uses the Hilbert curve. Compared to the usual matrices for error diffusion, the curve approach seemed easier to implement in some ways, as it has fewer edge issues.

More interestingly, it struck a chord with my earlier experiments with space-filling curves in image processing. So it was a kind of familiar territory, but it also seemed esoteric enough that I could imagine making some new discoveries. For example, play with other plane-filling curves besides the Hilbert.

The first image uses the boustrophedon curve, which makes the vertical wave patterns I recall from a number of non-dithering demos. The second curve is what I call the diagstrophedon, a diagonal zig-zag starting from the top left corner, and I think its wavy artefacts make a nice match for Venus's hair.

Then in image 3 we have Hilbert, which doesn't seem to make any particular artefacts, and I guess that's a good thing for dithering. Finally 4 uses the Peano curve, which makes some fun wiggles in light areas.

#dithering #riemersmadithering #stippling #halftoneart #raster #pixelart #hilbertcurve #peanocurve #planefillingcurve #spacefillingcurve #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Yet another optimized Voronoi tiling. This was supposed to be a simpler alternative to the previous tiling approach, but I ended up going down a rabbit hole of various dithering algorithms.

Instead of the equal-sum partitions, this uses regular dithering to find the Voronoi seed points, and the tile areas are inversely proportional to the colour values. My simple random dithering didn't work as well as expected, so I started to look into alternatives. I was of course aware of Floyd-Steinberg, and as I grew a bit tired of this demo, I ended up cheating a little by using a ready-made library. Since I was using PIL for image handling anyway, I could simply use its format conversion functions to get a 1-bit image, which uses F-S by default.

As before, I planned to use edge detection to get smaller tiles at the contrast edges. However, it didn't work so well with dithering, as it would concentrate basically all seed points at the edges. So here I used a mix of edge detection and the original. I think it worked out nicely here, as the bright colours often coincide with areas of small detail, while the dark background doesn't need much resolution.

#voronoidiagram #pixelart #blockart #tiling #raster #mosaic #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

I wanted to make the optimized tiling look more organic, and I've already played with Voronoi diagrams quite a lot. But this turned out a bit more messy than expected. To preserve the size and shape variations of the rectangles in the Voronoi cells, I ended up using a non-uniformly weighted metric. I guess it counts as a shape metric, using the definition in my Bridges 2020 paper.

As before, there's a roughly uniform tiling with an equal number of cells for comparison.

#voronoidiagram #pixelart #blockart #tiling #raster #mosaic #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

Another visual refinement to a recent demo: adding seams to the optimized tiling scheme. While it breaks the mosaic illusion to some extent, I think it makes the tile sizing idea much clearer. As before, there's a uniform variant with the same number of tiles for comparison.

Source photo: Mary of Egypt by José de Ribera, in public domain.

#pixelart #blockart #tiling #raster #mosaic #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

The recent stipplings and partitionings reminded me of this demo from about 2 years ago. In short, it's a Hilbert curve where the iteration level varies by the colour value. I wanted to make some small changes, but I ended up rewriting it completely. The shader approach seemed needlessly heavy and redundant for something that works more naturally on a CPU. But mostly it was just a fun exercise in looking at the same problem from a different angle.

The first picture shows the original idea. With the new idea, I wanted to get rid of the slanted lines; the result doesn't feel any better to me, but I guess it's interesting in its own way.

#hilbertcurve #planefillingcurve #spacefillingcurve #lineart #linedrawing #singlelinedrawing #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

I came across this halftoning idea sometime last week. While the idea was relatively easy to understand and fun to implement, I've spent quite a lot of time trying to make the result look nice.

In each row, the image is split into bins containing roughly the same sum of lightness value. This is nice to implement when the number of lines/bins is a power of 2, so we can recurse with a binary split. Thus the line density varies by average lightness. The problem is that density is considered along the x-axis. If things change a lot between rows, the lines get slanted, so they appear more dense. Here I've included some averaging between neighbouring rows to make thing a bit smoother.

I'm also including a fun glitch from the early tests. The line-density system includes the set of point coordinates and the graph structure (which point is connected to which). What happened here is my generic graph generator that simply finds the nearest neighbours of each point. So in the light areas that are compressed horizontally, the nearest neighbours were left and right.

#halftoneart #lineart #patterns #texture #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

I came across this halftoning idea sometime last week. While the idea was relatively easy to understand and fun to implement, I've spent quite a lot of time trying to make the result look nice.

In each row, the image is split into bins containing roughly the same sum of lightness value. This is nice to implement when the number of lines/bins is a power of 2, so we can recurse with a binary split. Thus the line density varies by average lightness. The problem is that density is considered along the x-axis. If things change a lot between rows, the lines get slanted, so they appear more dense. Here I've included some averaging between neighbouring rows to make thing a bit smoother.

I'm also including a fun glitch from the early tests. The line-density system includes the set of point coordinates and the graph structure (which point is connected to which). What happened here is my generic graph generator that simply finds the nearest neighbours of each point. So in the light areas that are compressed horizontally, the nearest neighbours were left and right.

#halftoneart #lineart #patterns #texture #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati

I came across this halftoning idea sometime last week. While the idea was relatively easy to understand and fun to implement, I've spent quite a lot of time trying to make the result look nice.

In each row, the image is split into bins containing roughly the same sum of lightness value. This is nice to implement when the number of lines/bins is a power of 2, so we can recurse with a binary split. Thus the line density varies by average lightness. The problem is that density is considered along the x-axis. If things change a lot between rows, the lines get slanted, so they appear more dense. Here I've included some averaging between neighbouring rows to make thing a bit smoother.

I'm also including a fun glitch from the early tests. The line-density system includes the set of point coordinates and the graph structure (which point is connected to which). What happened here is my generic graph generator that simply finds the nearest neighbours of each point. So in the light areas that are compressed horizontally, the nearest neighbours were left and right.

#halftoneart #lineart #patterns #texture #pythoncode #opengl #algorithmicart #algorist #mathart #laskutaide #ittaide #kuavataide #iterati