Similar to my #LinearMemory piece from last year (check the hashtag for references), these current #Actiniaria explorations make me fully appreciate all the research, efforts and supporting hardware behind the DCI-P3 & Rec.2020 color spaces. The intensity (and subtlety) of some colors & combinations are just stunning (to me), and I don't mean this in any ableist way (just enjoying whilst I still can!)...

Also still amazed that something like this runs at a smooth 60fps @ 2160x2160 UHD resolution on a mobile device with a just Snapdragon 2 chipset... As part of my advisory role @ day job, over the past few months I've been tasked with optimizing artworks for almost a dozen generative/algorithmic artists, often achieving 2-4x framerate improvements... Very much feeling a longer blog post re: code craft vs code art coming up, hoping to connect them more...

"To understand a program you must become both the machine and the program." — Alan Perlis

(Note: Sadly Firefox does not seem to respect the Rec2020 color profile in the video, please download or use Chrome or Safari for viewing...)

Been working on various shader & behavior update and options for #Actiniaria... it's all starting to come together!

(Note: Sadly Firefox does not seem to respect the Rec2020 color profile in the video, please use Chrome or Safari for viewing...)

Last post's stippling was based on partitioning the image into rectangular tiles, with one dot per tile. I wondered what the tiles themselves would look like; they are basically pixels of different sizes, so they might give an interesting view of the original image.

At first, this didn't look too exciting. The stippling idea was to make brighter pixels smaller, but with the tiles fully coloured, the halftoning idea won't work, and the small pixels are lost in large bright areas.

I still thought the general idea could be useful in some other way. What if the image was partitioned according to contrast edges? Then we'd have smaller pixels where we need more detail. This seemed to work after some adjustments, including smoothing for noise removal.

The effect doesn't look like much on its own, but a comparison against uniform pixelation makes it clear: both pictures have 4096 tiles, but one has a nicer distribution of sizes matching the details.

More #algorithmicArt which produces circles, in this case the circles are concentric if overlap. The procedure starts with one circle (in the simplest case, can be more) facing some direction, which produces a duplicate that jumps to another place, according to a given distance (relative to its size), increments its colour index and faces to another direction turning by a given angle. If the new circle lands on an occupied place, it is partially (or completely) eaten by the older circle, leaves an imprint in its center and then is excreted with colour change. The excreted circles continue to evolve as well. There is a limit in the minimum size for a circle to duplicate. Slight adjustments in the initial conditions can produce significant changes in the output. No randomness involved as usual.
I show two nice results I found in the vast space of possibilities, as well as a video showing the construction of the first one, and an imprint of the paths taken using circumferences.
#Mathart #creativecoding

SIFF turned me down: "Thank you for submitting INK to the 51st Seattle International Film Festival. We appreciate you taking the time and energy to send your film to us for consideration. Regretfully, we did not select your film to be presented at this year’s edition. "

Oh, well. You can still watch it here: https://vimeo.com/932750036 Enjoy!

Work in progress...

Finally finding some time to continue working on my earlier https://thi.ng/boids experiments, now also using WebGL instancing and floating point render textures for super-smooth blending/trails to create aesthetics reminiscent of sea anemones...

(Update: I've decided on the beautiful-sounding and fitting #Actiniaria as project title...)

(Note: Sadly Firefox does not seem to respect the Rec2020 color profile in the video, please use Chrome or Safari for viewing...)

Last post's line raster idea was kind of frustrating to get right, and I'm still not quite happy with the results. Of course, as soon as I'd posted them, I had a new idea for stippling images using the same 1D partitioning logic.

Now the binary partitioning proceeds alternately in x and y dimensions, splitting the whole image into areas of equal colour sum. It doesn't help with the line raster idea, and I'm not sure if it's great for general stippling either; it feels quite blocky compared to random dithering. But the technical idea seems quite fun — it should work in higher dimensions too.

I also made the minimum spanning tree, and it turned out quite interesting with the horizontal and vertical lines dominating large areas.

A sliced apple, processed with some recursive code I wrote.

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.

Oxidation and deconstructivism.

An accident (they are not supposed to intersect each other).

Work in progress (had a little breakthrough!).

Defrosting the depths

#AlgorithmicArt #CreativeCoding #maze
#Processing #glsl #shaders

Edited by Raivo Kelomees, Varvara Guliajeva, Oliver Laas - The Meaning of Creativity in the Age of AI

https://archive.neural.it/init/default/show/3297

Pastel pyre

#AlgorithmicArt #CreativeCoding #maze
#Processing

Sorted mosaic of white blossoms on a sidewalk.
Other mosaics here: https://www.flickr.com/photos/31382652@N00/albums/72157684474997934/

I've always found circuit boards aesthetically inspiring, and in recent years this fascination has turned into a number of PCB-styled demos. I think a key inspiration for these has been the "Absolut Intelligence" vodka advert a couple of decades ago.

I haven't done these in a while, but a week or two ago I ran into spanning trees. I noticed that spanning trees of square lattices can make rather nice impersonations of printed circuits, especially when the solder points are only put on leaf points. Cut the tree up into a forest, and it's making even more electrical sense.

Halftoning isn't new to me either, but my existing line-based techniques didn't look nice on the square PCB lattice. It had to be more blocky with exactly horizontal or vertical lines. So for this iteration, I've set each half-edge to have a constant width — a natural evolution of my earlier variants, which were built from half-edge sections. Of course, the solder points follow a similar areal scaling.

pen plotter art - a short history 1950s to now

https://penplotter.art/p/pen-plotter-art-history

h/t @gorillasun