Hello 0zera!
Welcome to Nodebox!
This is a really interesting problem, or rather problem space. It is definitely doable in Nodebox and should be a lot of fun.
The three examples you provide are each different. The first is straightforward. I could recreate Norm's system directly and produce every combination of a set of component line or curve segments. The basic technique would be to input a list of N segment shapes, generate all binary numbers from 0 to 2^N, and, for each binary number output segments corresponding to the one bits.
Sol LeWitt's system could be a simple extension of this technique using the twelve line segments of the isometric projection of a cube with additional constraints to cull some of the trivial or redundant patterns.
But that might miss the point. LeWitt was not just exhaustively generating permutations; he was creating specific arrangements in thought-provoking subgroups intended to be looked at from different angles. In other words, not a purely algorithmic construction (at least not a simple one). You could still play with that by generating a master list of possible open cube forms along with a table of properties, and then play with a series of algorithms acting on those properties to sift and sort and cull that list repeatedly to produce different interesting outputs.
Your third example seems like the one you are most interested in. This is quite doable in Nodebox and is similar in spirit to Truchet tiles. Making the tiles is easy. The problem is how to arrange them. Truchet tiles are in a simple fixed grid with a module at each grid position; you want something more complex with different-shaped modules and gaps here and there. You need to describe a more flexible system or grammar of possible arrangements.
NodeBox does have one serious limitation. It doesn't do recursion and, as a result, cannot directly create things like L-systems. You can find some conversation threads in the forum on this topic.
Where there's a will, however, there's always a way. I have demonstrated several techniques to create limited amounts of recursion entirely within Nodebox or by using a custom node. This case is simple enough to be tractable. So I think a simple system or grammar within certain limitations would be possible.
The more fundamental problem is: what, exactly, do you want to do? What framework would you like to work within?
I can think of several very different ways to fit modules together. You could take a binary random walk by generating a series of N bits, with 0 meaning curve left and 1 meaning curve right. Place the first white module at the origin, stick a red module on the end, and repeat using the last endpoint as the new origin. After a given length you could then draw an enclosing grid under the resulting path (you might wind up with an oblong grid).
OR, you could start with a grid of a fixed size and make individual placements which must fit entirely inside that grid. This would be more complex and might involve collision tests (which can be tricky).
These approaches are fairly specific to the modules referenced in your third example. You would probably like to develop a more general system. But this would involve choosing which degrees of freedoms you want to allow and what assumptions or constraints you want to make on possible module shapes.
I'm not sure how best to be of help here. If you like I can create some examples to get you started. I might use a node from the Cartan Node Library to generate binary numbers as that is an easy way to make combinations. You could then take my example, fiddle with it, try to push it a new direction and then come back when you get stuck. We could carry on a conversation like that as long as you want.
Let me know if I'm going too fast, too slow, or not being clear. I'll come back soon (Christmas holiday permitting) with at least one example and meanwhile can answer any questions you might have.
This looks like fun!
John
.png)
