the tree layout would be:
{0;0}(0) (first column, first point)
{0;0}(1) (first column, second point)
{0;0}(2) (first column, third point)
.....
{0;4}(8) (fifth column, ninth point)
.....
{0;9}(9) (last column, last point)
What if you want to connect every point in this grid with a point two levels higher up and one column over?
You can specify an offset like so:
{0;+1}(+2)
If we apply this offset to the list of items above, we'll get:
{0;1}(2) (second column, third point)
{0;1}(3) (second column, fourth point)
{0;1}(4) (second column, fifth point)
.....
{0;5}(0) (sixth column, first point)*
.....
{0;0}(1) (first column, second point)**
* If you overstep the list length and Item Wrap is set to false, you will not get any result. Otherwise you'll get the cycled item.
** If you overstep the number of paths and Path Wrap is set to false, you will not get any result.
At the moment it only supports whole integers, and the items in the offset are simply added to the original path+index. I'm not sure yet if I'll move towards expressions in the offset pattern. There are two components, one allows you to get relative items from the same data tree, the other from two distinct data trees.
--
David Rutten
david@mcneel.com
Seattle, WA…
Added by David Rutten at 11:25am on November 20, 2010
of tensiles ... the Birdair/Taiyo Kogyo combo is like the 3 big German luxury saloon car makers combined (I mean that in 99.99% of cases you'll end up buying a S Class or an ugly 7 series or that 8 quattro).
So ... in a nutshell: It's a ping-pong thing: you design the "outline", Birdair calculates the membrane related forces, you test custom components (MSC Nastran, STAAD, RAM etc), you get feedback from someone capable to do these in real-life (like Donges GmbH), you argue about the cost (hideous, as usual), you replace bespoke custom cast things with commercially available ugly bits ... etc etc etc.
The big issue is that the whole design is supposedly a thing carried over under "some" BIM umbrella ... therefore the master composer must be either Revit (no thanks) or AllPlan (ditto) or AECOSim (yes please).
But these archaic things they don't understand an iota from MCAD stuff (most notably the assembly/component discipline or advanced feature driven nested components). But all things considered Microstation + Generative Components + AECOSim + Bentley structural analysis verticals define the most complete solution that you can use.
Moral: Chaotic chaos, what else?
PS: I'll post the full (quite complex) GH definition soon - among other stuff: using the real-life items shown imported as blocks to Rhino and "mapped" in space (PlaneToPlane) via GH/C#.…
mpletes, i will be incremented. The default increment amount is 1.
If you change the syntax to be:
For i As Int32 = 0 To 9 Step 2
then i will be incremented by 2 each time. So now the loop will run 5 times:
first iteration i = 0
second iteration i = 2
third iteration i = 4
fourth iteration i = 6
fifth iteration i = 8
sixth iteration i = 10 which is more than 9 so the 6th iteration never happens.
If you use Step 0, i isn't incremented at all, and the loop should run forever, unless you have some other abort statement or if you adjust the iteration variables inside the loop. You are doing the latter. Your iteration variable is D. The loop itself does not increment it, but you manually increment it when you call D += T.
Although this is logically solid, it is very bad practice since it makes the code very hard to read.
Since D, R and N are not external variables, I would not expose them as Input parameters.
Also, you inner loop is very weird:
For R = R1 To R Step 0
Your iteration variable here is R, but your termination limit is also R. Not to mention the step is again zero.
Trying to debug this is very difficult because it's been written in a very unorthodox fashion. I have a distinct feeling this algorithm can be written down with far fewer variables and constructs.
--
David Rutten
david@mcneel.com
Poprad, Slovakia…
will work slightly different from before. Sorry about breaking this, but it proved impossible to improve the selection logic with the fairly ambiguous notation that was implemented already.
Not every change is breaking though and I hope that most simple matching rules will work as before. There will be a McNeel webinar on Wednesday the 6th of November where I discuss the new selection rules (as well as path mapping syntax and relative offsets within one or more data trees). This will be a pretty hard-core webinar aimed at expert users. The event will be recorded so you can always go and watch it later. I figured I'd briefly explain the new selection rules on Ning before I release the update though.
-------------------------------------------------------------------------------
Imagine we have the following data tree, containing a bunch of textual characters:
{0;0} = [a,e,i,o,u,y] {0;1} = [ä,ë,ê,ï,î,ö,ô,õ,ü,û,ÿ,ý] {1;0} = [b,c,d,f,g,h,j,k,l,m,n,p,q,r,s,t,v,w,x,z] {1;1} = [ç,ĉ,č,ĝ,ř,š,ş,ž]
There are a total of four branches {0;0}, {0;1}, {1;0} and {1;1}. The first branch contains all the vowels that are part of the standard English alphabet. The second branch contains all non-standard vowels and branches three and four contain the standard and non-standard consonants respectively.
So what if we want to select from this tree only the standard vowels? Basically include everything in the first branch and disregard everything else. We can use the [Tree Split] component with a selection rule to achieve this:
{0;0}
This selection rule hard-codes the number zero in both tree path locations. It doesn't define an item index rule, so all items in {0;0} will be selected.
If we want all the vowels (both standard and non-standard), then we have several options:
{0;?} = select all branches that start with 0
{0;(0,1)} = select all branches that start with 0 and end in either 0 or 1
{0;(0 to 1)} = ......................................... and end in the range 0 to 1.
Conversely, selecting all standard vowels and consonants while disregarding all non-standard character can be achieved with rules as follows:
{?;0}
{(0,1);0}
{(0 to 1);0}
It is also possible to select items from each branch in addition to limiting the selection to specific branches. In this case another rule stated in square brackets needs to be appended:
{0;?}[0 to 2]
The above rule will select the first three vowels from the standard and the non-standard lists.
Basically, rules work in a very consistent way, but there are some syntax conventions you need to know. The first thing to realize is that every individual piece of data in a data-tree can be uniquely and unambiguously identified by a collection of integers. One integer describes its index within the branch and the others are used to identify the branch within the tree. As a result a rule for selection items always looks the same:
{A;B;C;...;Z}[i] where A, B, C, Z and i represent rules.
It's very similar to the Path Mapper syntax except it uses square brackets instead of parenthesis for the index (the Path Mapper will follow suit soon, but that won't be a breaking change). You always have to define the path selector rule in between curly brackets. You can supply any number of rules as long as you separate them with semi-colons.
The index rule is optional, but -when provided- it has to be encased in square brackets after the path selection rule(s).
The following rule notations are allowed:
* Any number of integers in a path
? Any single integer
6 Any specific integer
!6 Anything except a specific integer
(2,6,7) Any one of the specific integers in this group.
!(2,6,7) Anything except one of the integers in this group.
(2 to 20) Any integer in this range (including both 2 and 20).
!(2 to 20) Any integer outside this range.
(0,2,...) Any integer part of this infinite sequence. Sequences have to be at least two integers long, and every subsequent integer has to be bigger than the previous one (sorry, that may be a temporary limitation, don't know yet).
(0,2,...,48) Any integer part of this finite sequence. You can optionally provide a single sequence limit after the three dots.
!(3,5,...) Any integer not part of this infinite sequence. The sequence doesn't extend to the left, only towards the right. So this rule would select the numbers 0, 1, 2, 4, 6, 8, 10, 12 and all remaining even numbers.
!(7,10,21,...,425) Any integer not part of this finite sequence.
Furthermore, it is possible to combine two or more rules using the boolean and/or operators. If you want to select the first five items in every list of a datatree and also the items 7, 12 and 42, then the selection rule would look as follows:
{*}[(0 to 4) or (6,11,41)]
The asterisk allows you to include all branches, no matter what their paths looks like.
It is at present not possible to use the parenthesis to define rule precedence, rules are always evaluated from left to right. It is at present also not possible to use negative integers to identify items from the end of a list.
If you want to know more, join the Webinar on Wednesday!
--
David Rutten
david@mcneel.com
Seattle, WA…
Added by David Rutten at 8:57pm on November 3, 2013
this was about some boring building I wouldn't respond ... but here we are talking sardines.
Here's my take on that matter:
1. The 4 C# first create/use a nurbs, then define some random planes (and transformations) and then (a) either they place some humble stripes or ... er ... (b) sardines as instance definitions (NOTE: Load Rhino file first).
2. All important decisions are the ones in yellow groups.
3. You control what you get via this (priority on stripes or sardines? that's the 1M Q):
4. If you decide for sardines (the right thing to do) then you must ENABLE the Sardiniser(C)(tm)(US patent pending) as follows:
5. The vodkaFactor on that Sardiniser C# adds some spice in the sardine placement (it does that by altering the priority on the "composite" transformation in use: first randomly rotate then planeToPlane .... or the other thing?).
6. Only the finest Da Morgada sardines are used in this definition:
7. Spot the WARNING in the filter related with what sardine to choose > do it wrong and no hard disk on your workstation > no risk no fun > sorry Amigos, he he.
8. 1M question for you all: why placing sardines (it's real-time you know) is WAY faster than creating these humble stripes?
9. Although the sardines are placed in real time as regards your CPU ... the critical factor is your GPU (display mode: rendered).
10.Still WIP (dancing sardines in the next update).
have some sardine fun, best, Lord of SardineLand…
t ''Morph'' turns Red saying ''Cannot morph from a degenerate box'' (image 2),
that's because every curve generates a box (image 3).
After what i check the Option ''Union'' box to make only one box for all the curves (image 4).
However, the result is aleatory and not accurate at all ... :/ (see image 6).I know you are developing Pufferfish and not ''Morph'' component, but recently you publish on instagram a video where i believe you could morph and Twist with success a collection of curves (please see image 7 and 8)...If you could give me a hint how that can be achieved, it would be awesome.(Piping/Meshing the curves with very small diameter will perhaps work and help for visualisation purposes, but i actually just need morphing Raw curves for fabrication purposes).Hope to read you very soon...Ghali,…
rogettisti, artisti di vari media, paesaggisti, studenti.
Orario_ 9.00-18.00 ( 1 ora pausa pranzo). 16 ore_2 giorni da 8 ore.
Descrizione_Il livello base di Grasshopper serve come introduzione al plugin parametrico Grasshopper per Rhino 3d. I partecipanti saranno esposti a flussi di lavoro di livello principiante /intermedio ed a strategie di progettazione per la MODELLAZIONE PARAMETRICA. L'accento sarà posto sulle tecniche di flusso di dati, la visualizzazione e l'analisi in grado di fornire una solida base per la futura ricerca e sviluppo.
Le lezioni saranno composte da una parte teorica ed una pratica in cui si svilupperanno esercizi basati su elementi di Design ed Architetture contemporanee.
Iscrizioni_ generativef@gmail.com
+info_Grasshopper Workshop_Livello base
Organizza_generativeflow.com
Chi_ I docenti saranno Marco Bonucci & Fernando Rial
___________________________________________
When?_ 27/28 October 2012 (Saturday and Sunday)
Where?_ AD Comunicazione. Via di Sant'Anna, 3, Roma. (Centro Storico)
Schedule_ 9:00 to 18:00 (1 hour lunch break). Ore_2 days_16 hours_8 h/day
Who is the target Audience?_Architects, Engineers, Industrial Designers, Interior Designers, Product Designers, Artists of various media, Landscapers.
Abstract_ The basic level of Grasshopper serves as an introduction to Grasshopper, the parametric plugin for Rhino 3d. Participants will be exposed to beginner / intermediate workflows and design strategies for PARAMETRIC MODELING. The focus will be on techniques of data flow, visualization and analysis that will provide a solid basis for future research and development.
Registration_ generativef@gmail.com
+ info_Grasshopper Workshop_Basic Level
Organizes_generativeflow.com
Who_ I docenti saranno Marco Bonucci & Fernando Rial
…
Added by Fernando Rial at 10:48am on October 18, 2012
ifically, in your picture, it looks like you're feeding two different pieces of data into the same Data input (D0) of the Anemone Loop Start component. If you zoom in on the component in Grasshopper, you'll see that you can add and subtract Data inputs via little +/- symbols, so you can have D0, D1, D2, etc. (Note: when you do this, Anemone Loop End will return an error if it doesn't have the same amount of Data inputs as the Loop Start, so be sure to add them there as well.) Attaching your original data to different inputs keeps them nicely separated during the looped Anemone process.
The nature (and usefulness) of Anemone is that it allows you to take data output by some functions and use it as the input for that same set of functions (normally forbidden under usual Grasshopper logic). So let's say that you want to take a sphere(Sphere0) and stack progressively smaller versions of that sphere on top of it. You feed the sphere into [Loop Start] as D0, and right away, it comes out of the [Loop Start] D0 output exactly the same, because nothing has happened to it yet. You take Sphere0 from the D0 output, let's say scale it by .8, and transform it up appropriately so it sits on top of the last sphere. Now you have Sphere1! Feed Sphere1 into the D0 input of [Loop End], and now (if the # of repeats allows) Sphere1 is the D0 output of [Loop Start]. So if it goes again, it'll scale and transform Sphere1, resulting in a smaller Sphere2, and so on and so forth for as long as you want. If you right-click on the [Loop End] component, you'll see some options labelled "Output after the last" and "Record Data". If neither option is checked, then you'll see the loop calculating in real time, and the only thing that will come out of the D0 output for [Loop End] is the smallest sphere. If you check only "Record Data," then D0 will contain all of the spheres made from the loops. If you check only "Output after the last," then you won't see anything output to D0 until it's entirely finished calculating all the loops. If you check both options, then D0 will output all the spheres, but only after it's finished calculating everything.
In my snake pictured here, there is a constant # of scales placed around each loop of the tube, let's say 10. But since the tube has variable circumferences, the size of the scales needs to vary based on the circumference of their loop. Furthermore, since the size of the scales varies, the distance between each loop must also vary so that there aren't unsightly gaps between loops. So you take the length of Loop0 and divide it by 20 (2 times the # of scales, since you only use every other scale to achieve this pattern), and use that as the distance between Loop0 and Loop1. But since Loop1 has a smaller circumference, Loop1 divided by 20 is going to yield a smaller number than the first one, and that's why you need to use Anemone to make a loop to find all of this out.
This might be more granular than you wanted, but I hope that some of it helps.
…
sent a 3D shape without any ambiguity. If the shape you're trying to convey falls outside the scope of existing standards, then it can't be done, but this is a problem of standards, not an intrinsic shortcoming of pencils.
[...] with the computer theoretically acting as a decision maker.
The computer makes no decisions on it's own. It's a fully deterministic machine, meaning that any output is the result of applying a set of rules to some pre-existing data. Humans make the rules. At no point can you blame the computer for coming up with a bad answer, it's always some human who is responsible.
[...] it seems to often be split between Computerization, and Computation.
I'm willing to concede there exist cases that are unambiguously one or the other, but there's a gradient in between these two extremes, they are not separate categories. If I draw a box by specifying the 8 corner points as XYZ coordinates then computation can be said not to be involved. If I draw a box by specifying 2 opposite corners then the computer has to compute the other 6 coordinates and we're already on our way towards the other extreme. If I draw a box by specifying a width, height and a required volume, more computation is needed. If I specify a box by a width, a volume and the requirement is doesn't cast too much shadow on some other shape, more computation is needed. At what point do we say "now it qualifies as computation/solving"?
--
David Rutten
david@mcneel.com…
Added by David Rutten at 7:22am on November 28, 2013