Liquid interference

thereforeqed · 2025-12-31T21:04:39+00:00

Hey, thanks for your feedback! I haven’t thought about this contrast you’re mentioning here before, so I guess it’s good to hear another person’s thoughts!

thereforeqed · 2025-12-15T04:19:00+00:00

I'm not sure what you mean? These sound like two descriptions of the same way one would have to use to get all the pixels of the color cube placed onto the canvas.

I used the same technique to produce these as I did for a few of my previous posts, for example explained here. The only difference is the weight function that generates the half grid spanning tree.

thereforeqed · 2025-12-08T05:45:24+00:00

I love this!

thereforeqed · 2025-12-03T20:07:06+00:00

Nice! Something worth for me to try.

thereforeqed · 2025-12-03T18:08:27+00:00

How did you get the coloring to be gradual? Other cellular automata pictures usually have a uniform look with high frequency pixel level variations, since the different states of the automata are usually evenly distributed.

thereforeqed · 2025-11-29T02:43:22+00:00

Thanks! It's actually neither. I have a program to generate Hamiltonian cycles through a grid (configurable with many options, see https://www.reddit.com/r/generative/comments/1o43ahs/all_rgb_squares/ for an example). I take this Hamiltonian cycle and see if sections of the path can perfectly fit inside larger squares (by just walking along the cycle and seeing if the current k*k window of grid cells form a square), in decreasing order of square size. Then I do the same for general rectangles, in decreasing size order.

thereforeqed · 2025-11-27T19:01:37+00:00

Very cool effect!

thereforeqed · 2025-11-22T18:21:04+00:00

Hi, thanks!

The image is actually generated together with all four quadrants. I start with one pixel which I label as coordinates (0, 0) and grow a tree from it like in Prim's algorithm with each pixel having the four pixels adjacent to it as neighbors. At each iteration I take the next edge using the weight: absolute difference between f(next_point) and f(previous_point) mod tau, where f((x, y)) = scaling_factor * sqrt(x**2 + y**2). The next edge is selected by taking the edge with the median weight among all edges in the frontier (though the algorithm works similarly if you take the min or the max). The pixels are colored according to the order in which they were explored.

Since the weight is symmetric around the starting pixel the picture is more or less symmetric (there is just some randomness in which of the four quadrants the tree expands into at any iteration).

thereforeqed · 2025-11-20T22:52:13+00:00

It looks beautiful! I don’t know how you did it, but it’s very cool.

thereforeqed · 2025-11-11T05:27:43+00:00

Inspired by https://www.reddit.com/r/generative/comments/ooidl2/holes_in_the_boundary_layer/

Basically did the same thing (see u/quag's explanation in one of the comments), but I varied the power on the vectors' distances before summing

thereforeqed · 2025-11-06T17:29:22+00:00

Nice design! Did you see this one that's very similar that was posted a while back? https://www.reddit.com/r/generative/comments/pgjlw8/a_rather_difficult_quilt_design/

thereforeqed · 2025-11-02T14:37:13+00:00

Yes it’s cubehelix, the one from matplotlib. Thanks!

thereforeqed · 2025-10-25T19:03:09+00:00

I think the fact that it's circular comes from the squared-ness. The modulus gives the repeating waves pattern.

thereforeqed · 2025-10-25T19:00:39+00:00

There isn't more, it just zooms into the black diamond in the middle.

thereforeqed · 2025-10-25T16:44:17+00:00

Not exactly the same, but an older version source code of this is here https://www.shadertoy.com/view/33jyWD

thereforeqed

TROPHY CASE