everything I noted is solely and completely -not even aesthetic- but just traced from the image I have no idea of what’s really going on from an architectural point of view, I just go full throttle when see patterns… they make me angry and anxious to understand their rules

The way I see it it’s acceptable and for aesthetic reasons to not have both void edges aligned.

I believe structurally that would work out with mortar and brick ties for these single leaf brick patterned walls.

That wasn’t intentional but a really good example by @inno ! It will definitely help with the distribution of voids across each line, or the facade. Guess it will be in the “ideal to have in the next step” category.

The gif you shared @maje90 - I think it will still take exponential time to run it across large facade - maybe the rule can be tweaked to be

Full brick

Full brick + small void

Full brick + large void

which will avoid back to back voids?

can I add you to my fav for any future pattern questions SIR!

@maje90 looking at this again - I’m actually stuck at how to put down this random sequence of bricks… I was creating something on this line last night where:

1 = full brick

2 = full brick + small void

3 = full brick + bigger void

and jitter these to a partition list and have it run N times

But I couldn’t figure out how to actually place them onto the row?

This is helpful to understand! I had the similar approach to the construction of rectangles!

I guess I’m trying to have a go combining both case studies - to begin with as something to test.

So it will be a series of 123/ 213/ 312/ 132 etc. and they can be oriented to the desired grid with the fixed total length.

But I can’t quite figure out how to make this “random” combo happen in a row.

Another thinking is to have the points to move in X direction by distance set out in 1, and then move from the new location by 2, and by 3, and make this process in random order - though not sure how this works either… brain fried

Sorry that I’ve not yet posted anything else but questions… I’m thinking about a method that will cover all the cases (curved surfaces, etc etc)…

Also I’m a bit lost on all the posts… are the bricks now just a single length?

And… the voids, I’m thinking they could be a indefinite length, not some prefixed lengths…

Appreciate that!

Yes it gets a bit confusing I can see - but I guess what I have summarised above is kind of what I’m after. Maybe as a starting point - that will help get to the ultimate solution you are trying to work out on curved surface etc?

I guess the purpose is that we can define void sizes from a list of selections? In theory brick lengths and voids can all be any number, but for this instance I’m after a full brick length, and a couple of void sizes to begin with if it makes sense?

Nice subject, I have no time to dig in but I made some search and I saw the question was asked sometimes ago, without answer!

@inno can I please ask why you used the flip matrix there after you constructed the rectangle grids? I can’t seem to be able to tell what it’s doing there

hi @laurent_delrieu I’ve seen quite a few great answers from you while searching for some related “packing” method.

@inno has summarised extremely well and shared with us all his research/discovery! It’s worth looking into when you have some time. The method he described worked well from the look of it too.

I guess I’m now leaning towards learning how to achieve something like the golden cinema as mentioned above in gh…

Would be happy for you to share your thoughts when you are free

… indeed.

Even if you don’t have time, can you give us your precious opinion on how you would tackle the matter?

Iterative? Random attempts + check? … something else?

Replicating 1:1 the same idea of that museum is sort of sad… I’m purposely not trying to force it to be same-looking…

What I’m thinking is an “algorithm” like this (which will be probably fully inside a c# script):

Main input are:

- a list of curves, each curve is a row of bricks.
- a black-white colored mesh that exist near the the list of curves, it defines the likeliness the script will attempt to skip some space before putting a brick (so it’s a “void”)
- a list of numbers defining the possible brick lengths
- an interval, defining the shortest and largest void

Main output will be sub-curves, each sub-curve will be a brick.

The code:

For each curve (or brick row/layer), iteratively “eat” a chunk of the curve to create bricks or void. Each “byte” length and type is dependant on some random and the local color of the mesh, each byte have to “avoid” points of previous row/layer. Each brick start/end (maybe mortar also) will be marked with a point, and each void will **filled** with points.

I’m really excited to see how you work it out! Sounds way beyond what I can do in gh, let alone C#…

Meanwhile if you could for the same of it - “force it to be” similar-looking to the golden cinema case that will be appreciated! @maje90

the output list C of a Grid component has a different branch for each column-array of cells (along the Y axis of the plane they are created on)

because the pattern was repeating horizontally, I wanted them to be organized by rows instead of columns, and flipping the List does exactly that

Thanks for your explanation! That makes sense.

I figured out most of your script except for the part where you had 70 (input for numbers of rows) wired to a random, and there are some other repeat by 100 (columns) which is splited into 3 groups - I already understand the 3 ranges to move to avoid having 2 voids on top of each other so what’s the purpose of these “repeat, random, list item and mass addtion”, and we can’t we just directly input the 3 ranges as variable to move the starting point of each cell?

Sorry I already shut down my laptop and typing on phone… I can add in the screenshot tomorrow if this is confusing!

hehehe

the whole (A) exists to create a list of 0s, 1s, 2s with the amount of 0s, 1s, 2s I want

as it is depicted it’s adding 70x number 2, 18x number 0, 12x number 1

this way I can decide ahead how many times the next pattern will fall on case0, case1, case2 (I wanted case2 to be 70%, case0 to be 3/5 of the remaining, and case1 to be whatever else remaining [2/5] )

the thing is that this list is merged, so numbers are not shuffled but just 70x 2s, then 18x 0s and 12x 1s: Jitter (B) shuffles the list so I have a somehow random order of 0, 1, 2 (of course 2s are still 70% of the total so…)

(C) generates one value in the range [0,1] per row

(D) assigns a numeric range to the numbers shuffled in (B)

(E) applies the random [0,1] number from (C) to the right range in (D)

in such a way when I get for instance 0.35 of caseX, it will calculate the actual amount of shift that correpsonds to the pattern being shifted 35% of the total available shifting length of caseX

(F) calculates the partial shifts -stacked over each other- that are then applied to the various rows in the original Grid

Hello

perhaps this plugin could be useful ?

thanks @seghierkhaled ! I’ve been busy today so will take a look at this and get back to you - still a tiny bit of voids on top of each other but yes it’s very close to the result!! Thanks again for sharing

holy cow @inno - hats off to you SIR!

I’ve been so busy at work today - I will take a proper look later tonight but I think this makes a lot more sense already! Also I learnt what “mass addition” does too - just - it helps with the issue I had previously where I couldn’t figure out how to add the next one on top of the previous one (again maybe I’m wrong but this is more or less what I understood from a friend).

What’s “trash” in someone’s eys is “gold” for people who needs it like me!

it helps with the issue I had previously where I couldn’t figure out how to add the next one on top of the previous one

exactly

and * this* “0” that is added to the Partial Result output of the Mass Addition that goes to the X-vector is there to add a zero-length vector as first item, in such a way the very first pattern is shifted by 0 units, and all the next ones are shifted by the partial-sum of all the previous ones

that said, it would be better to add at least * that* modulus component that trims the length of the shifts in such a way you don’t get a final pattern that moves in a diagonal fashion around the screen…

still, very poorly implemented