re is my problem... I need to arrange Boxes in the most efficient way within boundaries of object and follow the following constraints.
The Goal: To fit 125 boxes in the most efficient way inside the total area. Starting Variables:
(1) 40% of the Boxes need to be between 60 and 85MSQ. (2) 40% of the boxes need to be between 86 and 110MSQ.
(3) 20% of the boxes need to be between 111 and 125mSQ. The breakdown doesn’t have to be exact to give the script some flexibility. Meaning you can have 41% +39% +20% = 100%.
Constraints:
1. A total MAXIMUM area of approximately 1600M per layer.
2. A maximum of 8 layers for a total of 12,800M per layer. Optimization can make as little or as many as 8 layers vertical to accommodate all boxes. So if script can achieve with 3 levels great. If needed all 8 levels, that's fine too. However, pay attention to next constraint (#3).
3. Approximately 15% of that space on each layer is off limits. (internal area) (blue area in example script) and the shape of the boundary cannot be modified to accommodate box design resulting in jagged lines for the internal area.
4. All generated squares/rectangles must have at least 3m touching an outside border (The Green lines).
5. All boxes must also be touching minimum 1M of border of the blue line.
6. If the boxes generated go outside the green boundary, they must be fillet to maintain the straight lines of the green boundaries.
7. Get as many of the boxes as possible a view towards the dots.
Could any one provide me a method or a way to start, if there are any useful links, please share with me. Thank you!
…
the paths.
Structure one (paths = 2)
{1;0;0;0;0}(N=10)
{2;0;0;0;0}(N=10)
Structure two (paths = 2)
{1;0;0;0}(N=10)
{2;0;0;0}(N=10)
If i merge the two lists i don't get a structure with 2 paths:
Structure result af merging (2 paths)
{1}(N=20)
{2}(N=20)
as i had expected, but instead a structure with 4 paths because of the difference in amount of zeroes:
Structure result af merging (4 paths)
{1;0;0;0;0}(N=10)
{2;0;0;0;0}(N=10)
{1;0;0;0}(N=10)
{2;0;0;0}(N=10)
The amount of zeroes changes all the time when working on the definition, so what im asking is if there some way to adress paths with * number of zeroes behind.…
tached is what I have managed to do thus far, which is only having two different types of pattern using greater than and smaller than. so just wondering if there is a way to divide them into a groups of 5 and use them later for different manipulations.
1st group: <25
2nd group: <20>25
3rd group: <15>20
etc
Thanks!
…
en that name). For example, in my grammar:
F = FXX = %(50:F[-X][+X]; 30:F[-X][X][+X]; 20:F[X])Axiom => F0 - F1 - FX2 - FF[-X][+X] with some seed, or FF[-X][X][+X] with other seed, or FF[X] with other.
And context-sensitive means, for example in my grammar, the rule:X = >(-F:+FX; +F:F[-F[-X][+FX]]) if the previous symbols (in the string of L-System, on the left when a X is read) is a -F, then X will be +FX, but if the symbol is +F, then X will be F[-F[-X][+FX]].
Or:
X = G(2: +++F; 3:++F; 4:+F) means that in the second generation X will be +++F, in the fourth will be +F.
Or:
X = IF(BL = 3: +F, -F) It means that if the branch level (BL) of X is 3, will be +F, otherwise -F.
And parametric is something like:
F = F(ValueA:x+0.5; ValueB: 6*BL), F have two metadata (ValueA and ValueB), and when "x" is read, is replaced by the value of that attribute of his predecessor, ie, will be the ancestor valueA+0.5. And BL is the branch level of X, which means that if X have a Path like {0,0,1} or {0,3,0} (three indices), ValueB will be 12, for that X in that generation/iteration.
…
9 8 7 6
5 4 3 2 1 0
I am triangulating this surface. I want to select just the red vertices. As you can note, I just need the inner vertices of this surface. I could do it mannually, but if I want to change the mesh density later, I will have to pick all of them manually again later.
Can someone help me?
Tks
…
pe Description = 41 byteType Name = 6 byteIs valid = 1 byteIs valid why not = 0 byte (let's assume everything works)Value = 8 byteTotal for GH_Number: 46 bytes, 8 of which are used for the number, 38 for saying it's a number). 2.400.000 x 46 byte = 105MB for one set of data. (a quick runtime check seems to confirm this is the right ballpark)
My conclusion for using big data in grasshopper needs some additional love at the moment. Currently the datatree structure becomes less useful when starting to go beyond the order 100,000, after this I usually consider writing some C# solution. Main reason usually is the runtime, not memory: executing the multiply command for example for 2.4 million times takes 20 seconds here (I'm not that patient).…