Crystallon is an open source project for creating lattice structures using Rhino and Grasshopper3D. The goal is to generate lattice structures within Rhino’s design environment without exporting t
ld be the best UI.
I think difference is made by 'Slider = 10' vs 'Slider = 10.000' more than by simple input/component initialization so, why to stop when it could be even more powerful?
Slider = 0 To 5 --- Slider in [0, 5]
Slider = {3; 0 To 5}
Slider = {3;0;5}
Slider = 3;0;5
Slider = 3 0:5
Slider = 3,0,5
Slider = 3 0 5 --- Value and range (min max)
3 0.0 5 --- 3.0 0.0 5.0
3 0 5.0 --- 3.0 0.0 5.0
3.0 0 5 --- 3.0 0.0 5.0
-1 0 5 --- 0 0 5 (-1 -1 5)
6 0 5 --- 5 0 5 (6 0 6)
Slider = 0:2:6 --- Even numbers: 0, 2, 4, 6.
Slider = 1:2:7 --- Odd numbers: 1, 3, 5, 7.
0:2:5 --- 0:2:4 (or 0:2:6)
3:2:8 --- 3:2:7 (or 3:2:9)
3 1:2:7 --- 1 3 5 7 (value 3)
Bang! = 7 --- 7 outputs
Merge = 5 --- 5 inputs
What's your opinion about Bang! = 7? As it's setting number of inputs, should it use different format? Bang! 7? Bang! (7)? Bang! i7?
+ * - / \ % ^ & | ! = > --- Addition, Multiplication, Subtraction, Division, Integer Division, Modulus, Power, AND, OR, NOT, Larger than, &c.
= could be a problem.
\ Integer division or Set difference?
! could be NOT but also Factorial.
| could mean intersection.
& could mean concatenate.
1+ --- Addition: input A = 1
2* --- Multiplication: input A = 2
+{0,1,1} --- Addition: input B = {0,1,1}
0-, 1/, 2^, 10^, e^ have their own components
Flatten = {7} or Flatten = 7 --- Input P = {7} (off-topic: Why can’t P be a list?)
Pt = {1, 2, 3} --- Point XYZ, X = 1, Y = 2, Z = 3.
Swatch = 129,239,231 (102)
Swatch = 129 139 231 102
F2 = "x^2+y"
"List Length" and "List Insert" don't work properly: "Value List" is choosen. Why? What's the reason to this choice? Well, I'd like to know how the whole thing (search by keywords) works, David.
Name and nickname can be now used as keywords. "Larger" works for ">" but "greater" doesn't. Could it be improved? Could synonyms be used? Could a short description even be used (I know this could be a bit weird)?
more than --- >
more or less --- Similarity
more less --- Similarity
red green --- Sets.List components should be showed
lightning --- Split Tree
What about use Curve.Analysis or Math.Boolean to display those Tab.Panel components? Param, Math, Sets, Vector? Primitive, Special, Util? Tab, Panel, and Tab.Panel as keywords.
At the moment that I write this, I check that ignoring accents in keywords has almost been included (0.8.0009): p`anel, pañel, pánel --- panel (almost)
Shouldn’t 'Dom2' work for Dom²?
What about nested search? You type some keywords (say 'Params' or 'Params.Geometry', or 'red green', or 'lst') and then you make a fine-tunning search over previous results/keywords. Tab.Panel and/or nested geometry could be useful when search by plug-in is desired or when you want to search among .ghuser components (first 'ghuser' or 'Extra.MyPlugIn' or 'lst' keyword and then fine-tunning, specific, search).
Is 'list length' performing this nested search right now ('lst' > 'length')? Anyway, I am thinking about UI (graphical) changes; successive searches.
As I said, description (and even words from the help info) could be used to search. What about "some kind of tags"? I mean that if 'list l' to finally choose List Length has been used for a while, that could be learned. Eventually, an XML file could store these tags, so you could even edit them. That could implement description, name, nickname, help info, Tab.Panel, .ghuser, synonyms (lots of them), tags/shortcuts or wathever.
How could flatten/graft/reverse be used? Initialize graft+Simplify or graft+Bang! could be really useful.
What about expressions? I don't how could it be done properly: would Slider = x^2 (expression) work? I mean, aren't expressions parsed when initializing?
Is Panel somehow doing this? 'panel = wathever' always suppose that wathever is a string, so you can't use 'panel = <pi>'. Sets.Strings components also do this.
I've been about to write several paragraphs about height/width (resizable components: Panel, Graph Mapper, Slider, &c.), input/output names (Scripts, F components; or any component with editable input/output names), orientation (Scribble), type hint and access option, nickname, &c. but, to sum up: being able to set any property when initializing would be really useful. I'd like to know the best choice of syntax but I'm sure that, David, you're closer to the answer. What do you think about this?
Slider: 3 0 5 "MySlider" "Slider^2"
Panel: "This is the content" "This is the title"
VB: "N" List Integer 7 "r" Item Double
Addition: A 1 B 2
I guess that any unified syntax would be elegant and useful, but additional ad hoc syntax (per component) could be even better (cleaner).
What about use lists of values? I'm not sure about format: panel = ("Hello", "Bonjour", "Hola")? If any valid format/syntax is found, maybe more sophisticated fetaures could be achieved: panel = {0;0} ("A", "B", "C") {0;1} ("1", "2", "3") How would you like this to be implemented?
There is a much simpler and interesting feature that would be useful, in my opinion: being able to initialize more than one component. I mean say 7xSlider = 10.0 and get 7 sliders and I also mean multiline (multi-component) initialization: Ctrl+Intro when you want to start a new line and Intro (or even some Accept/Cancel buttons when you activate multiline mode) to initialize (every line/component), for example. I mean:
3 x Slider = 1
Panel
Mass addition
Panel
And the whole bunch of components that were in mind (pre-thinked definition) is initialized. It speeds up the workflow, making more dynamic to add components that are only available via the drop-down panels.
Should this multiplier be something like a text box adjacent to search field more than '7x'?
These are some of my thoughts about intitializing. Please let me know your opinion :]
…
This blog post is a rough approximation of the lecture I gave at the AAG10 conference in Vienna on September 21st 2010. Naturally it will be quite a different experience as the medium is quite…
Added by David Rutten at 3:27pm on September 24, 2010
ndard length elements without any cutting, and using only simple connections, such as cable ties or scaffold swivel couplers.
To summarize the approach I present here:
Design an initial shape
Remesh this form so that the edges are all roughly the length of the tubes we will use to build the structure
Rotate and extend the edges of this mesh to create the crossings
Apply a relaxation to optimize the positions of the tubes for tangency
demo_reciprocal_structures.gh
Initial form
In this example I show how to apply this system to a simple sphere. You can replace this with any arbitrary shape. It can be open or closed, and have any topology.
Remeshing
The new ReMesher component takes an input mesh, and a target edge length, and iteratively flips/splits/collapses edges in order to achieve a triangulated mesh of roughly equal edge lengths.
Press the Reset button to initialize, then hold down the F5 key on your keyboard to run several iterations until it has stabilized. (F5 just recomputes the solution, and this can be a quick alternative to using a timer)
Once the remeshing is complete, bake the result into Rhino and reference it into the next part of the definition (I recommend doing this rather than connecting it directly, so that you don't accidentally alter the mesh and recompute everything downstream later).
Alternatively you can create your mesh manually, or using other techniques.
Rotate and Extend
We generate the crossings using an approach similar to that described by Tomohiro Tachi for tensegrity structures here:
http://www.tsg.ne.jp/TT/cg/FreeformTensegrityTachiAAG2012.pdf
Using the 'Reciprocal' component found in the Kangaroo mesh tab, each edge is rotated about an axis through its midpoint and normal to the surface, then extended slightly so that they cross over.
By changing the angle you can change whether the fans are triangular or hexagonal, and clockwise or counter-clockwise.
Choose values for the angle and scaling so that the lines extend beyond where they cross, but not so far that they clash with the other edges.
Note that each rod has 4 crossings with its surrounding rods.
There are multiple possibilities for the over/under pattern at each 'fan', and which one is used affects the curvature:
A nice effect of creating the pre-optimization geometry by rotating and extending mesh edges in this way is that the correct over/under pattern for each fan gets generated automatically.
Optimization for tangency
We now have an approximate reciprocal structure, where the lines are the centrelines of our rods, but the distances between them where they cross vary, so we would not actually be able to easily connect the rods in this configuration.
To attach the rods to form a structure, we want them to be tangent to one another. A pair of cylinders is tangent if the shortest line between their centrelines is equal to the sum of their radii:
Achieving tangency between all crossed rods in the structure is a tricky problem - if we move any one pair of rods to be tangent, we usually break the tangency between other pairs, and because there are many closed loops, we cannot simply start with one and solve them in order.
Therefore we use a dynamic relaxation approach, where forces are used to solve all the tangency constraints simultaneously, and over a number of iterations it converges to a solution where they are all met. The latest Kangaroo includes a line-line force, which can be used to pull and push pairs of lines so that they are a certain distance apart. Each rod is treated as a rigid body, so forces applied along its length will cause it to move and rotate.
The reciprocal component uses Plankton to find the indices of which lines in the list cross, which are then fed into the force for Kangaroo. We also use springs to keep each line the same length.
If the input is good, when we run the relaxation (by double clicking Kangaroo and pressing play), the rods should move only a little. We can see whether tangency has been achieved by looking at the shortest distance between the centerlines of the crossing rods. When this is twice the rod radius, they are tangent. Wait for it to solve to the desired degree of accuracy (there's no need to wait for 1000ths of a millimeter), and then press pause on the Kangaroo controller and bake the result.
The radius you choose for the pipes, curvature of the form and length of the edges all affect the result, and at this stage you may need to tweak these input values to get a final result you are happy with. If you find the rods are not reaching a stable solution but are sliding completely off each other, you might want to try adding weak AnchorSprings to the endpoints of the lines, to keep them from drifting too far from their original positions.
For previewing the geometry during relaxation I have used the handy Mesh Pipe component from Mateusz Zwierzycki, as it is much faster than using actual surface pipes.
To actually build this, you then need to extract the distances along each rod at which the crossings occur, and whether it crosses over or under, mark the rods accordingly, and assemble (If there is interest I will also clean up and post the definition for extracting this information). While this technique doesn't require much equipment, it does need good coordination and numbering!
There is also a ReciprocalStructure user object component that can be found in the Kangaroo utilities tab, which attempts to apply steps 3 and 4 automatically. However, by using the full definition you have more control and possibility to troubleshoot if any part isn't working.
The approach described here was first tested and refined at the 2013 Salerno Structural Geometry workshop, lead by Gennaro Senatore and myself, where we built a small pavilion using this technique with PVC tubes and cable ties. Big thanks to all the participants!
Finally - this is all very experimental work, and there are still many unanswered questions, and a lot of scope for further development of such structures. I think in particular - which of the relative degrees of freedom between pairs of rods are constrained by the connection (sliding along their length, bending, and twisting) and how this affects the structural behaviour would be interesting to examine further.
Steps 3 and 4 of the approach presented above would also work with quad meshes, which would have different stability characteristics.
There is also the issue of deformation of the rods - as the procedure described here solves only the geometric question of how to make perfectly rigid straight cylinders tangent. The approach could potentially be extended to adjust for, or make use of the flexibility of the rods.
I hope this is useful to somebody. Please let me know if you do have a go at building something using this.
Any further discussion on these topics is welcome!
Further reading on reciprocal structures:
http://vbn.aau.dk/files/65339229/Three_dimensional_Reciprocal_Structures_Morphology_Concepts_Generative_Rules.pdf
http://www3.ntu.edu.sg/home/cwfu/papers/recipframe/
http://albertopugnale.wordpress.com/2013/04/05/form-finding-of-reciprocal-structures-with-grasshopper-and-galapagos/
…
ng is deciding how and where to store your data. If you're writing textual code using any one of a huge number of programming languages there are a lot of different options, each with its own benefits and drawbacks. Sometimes you just need to store a single data point. At other times you may need a list of exactly one hundred data points. At other times still circumstances may demand a list of a variable number of data points.
In programming jargon, lists and arrays are typically used to store an ordered collection of data points, where each item is directly accessible. Bags and hash sets are examples of unordered data storage. These storage mechanisms do not have a concept of which data comes first and which next, but they are much better at searching the data set for specific values. Stacks and queues are ordered data structures where only the youngest or oldest data points are accessible respectively. These are popular structures for code designed to create and execute schedules. Linked lists are chains of consecutive data points, where each point knows only about its direct neighbours. As a result, it's a lot of work to find the one-millionth point in a linked list, but it's incredibly efficient to insert or remove points from the middle of the chain. Dictionaries store data in the form of key-value pairs, allowing one to index complicated data points using simple lookup codes.
The above is a just a small sampling of popular data storage mechanisms, there are many, many others. From multidimensional arrays to SQL databases. From readonly collections to concurrent k-dTrees. It takes a fair amount of knowledge and practice to be able to navigate this bewildering sea of options and pick the best suited storage mechanism for any particular problem. We did not wish to confront our users with this plethora of programmatic principles, and instead decided to offer only a single data storage mechanism.*
Data storage in Grasshopper
In order to see what mechanism would be optimal for Grasshopper, it is necessary to first list the different possible ways in which components may wish to access and store data, and also how families of data points flow through a Grasshopper network, often acquiring more complexity over time.
A lot of components operate on individual values and also output individual values as results. This is the simplest category, let's call it 1:1 (pronounced as "one to one", indicating a mapping from single inputs to single outputs). Two examples of 1:1 components are Subtraction and Construct Point. Subtraction takes two arguments on the left (A and B), and outputs the difference (A-B) to the right. Even when the component is called upon to calculate the difference between two collections of 12 million values each, at any one time it only cares about three values; A, B and the difference between the two. Similarly, Construct Point takes three separate numbers as input arguments and combines them to form a single xyz point.
Another common category of components create lists of data from single input values. We'll refer to these components as 1:N. Range and Divide Curve are oft used examples in this category. Range takes a single numeric domain and a single integer, but it outputs a list of numbers that divide the domain into the specified number of steps. Similarly, Divide Curve requires a single curve and a division count, but it outputs several lists of data, where the length of each list is a function of the division count.
The opposite behaviour also occurs. Common N:1 components are Polyline and Loft, both of which consume a list of points and curves respectively, yet output only a single curve or surface.
Lastly (in the list category), N:N components are also available. A fair number of components operate on lists of data and also output lists of data. Sort and Reverse List are examples of N:N components you will almost certainly encounter when using Grasshopper. It is true that N:N components mostly fall into the data management category, in the sense that they are mostly employed to change the way data is stored, rather than to create entirely new data, but they are common and important nonetheless.
A rare few components are even more complex than 1:N, N:1, or N:N, in that they are not content to operate on or output single lists of data points. The Divide Surface and Square Grid components want to output not just lists of points, but several lists of points, each of which represents a single row or column in a grid. We can refer to these components as 1:N' or N':1 or N:N' or ... depending on how the inputs and outputs are defined.
The above listing of data mapping categories encapsulate all components that ship with Grasshopper, though they do not necessarily minister to all imaginable mappings. However in the spirit of getting on with the software it was decided that a data structure that could handle individual values, lists of values, and lists of lists of values would solve at least 99% of the then existing problems and was thus considered to be a 'good thing'.
Data storage as the outcome of a process
If the problems of 1:N' mappings only occurred in those few components to do with grids, it would probably not warrant support for lists-of-lists in the core data structure. However, 1:N' or N:N' mappings can be the result of the concatenation of two or more 1:N components. Consider the following case: A collection of three polysurfaces (a box, a capped cylinder, and a triangular prism) is imported from Rhino into Grasshopper. The shapes are all exploded into their separate faces, resulting in 6 faces for the box, 3 for the cylinder, and 5 for the prism. Across each face, a collection of isocurves is drawn, resembling a hatching. Ultimately, each isocurve is divided into equally spaced points.
This is not an unreasonably elaborate case, but it already shows how shockingly quickly layers of complexity are introduced into the data as it flows from the left to the right side of the network.
It's no good ending up with a single huge list containing all the points. The data structure we use must be detailed enough to allow us to select from it any logical subset. This means that the ultimate data structure must contain a record of all the mappings that were applied from start to finish. It must be possible to select all the points that are associated with the second polysurface, but not the first or third. It must also be possible to select all points that are associated with the first face of each polysurface, but not any subsequent faces. Or a selection which includes only the fourth point of each division and no others.
The only way such selection sets can be defined, is if the data structure contains a record of the "history" of each data point. I.e. for every point we must be able to figure out which original shape it came from (the cube, the cylinder or the prism), which of the exploded faces it is associated with, which isocurve on that face was involved and the index of the point within the curve division family.
A flexible mechanism for variable history records.
The storage constraints mentioned so far (to wit, the requirement of storing individual values, lists of values, and lists of lists of values), combined with the relational constraints (to wit, the ability to measure the relatedness of various lists within the entire collection) lead us to Data Trees. The data structure we chose is certainly not the only imaginable solution to this problem, and due to its terse notation can appear fairly obtuse to the untrained eye. However since data trees only employ non-negative integers to identify both lists and items within lists, the structure is very amenable to simple arithmetic operations, which makes the structure very pliable from an algorithmic point of view.
A data tree is an ordered collection of lists. Each list is associated with a path, which serves as the identifier of that list. This means that two lists in the same tree cannot have the same path. A path is a collection of one or more non-negative integers. Path notation employs curly brackets and semi-colons as separators. The simplest path contains only the number zero and is written as: {0}. More complicated paths containing more elements are written as: {2;4;6}. Just as a path identifies a list within the tree, an index identifies a data point within a list. An index is always a single, non-negative integer. Indices are written inside square brackets and appended to path notation, in order to fully identify a single piece of data within an entire data tree: {2,4,6}[10].
Since both path elements and indices are zero-based (we start counting at zero, not one), there is a slight disconnect between the ordinality and the cardinality of numbers within data trees. The first element equals index 0, the second element can be found at index 1, the third element maps to index 2, and so on and so forth. This means that the "Eleventh point of the seventh isocurve of the fifth face of the third polysurface" will be written as {2;4;6}[10]. The first path element corresponds with the oldest mapping that occurred within the file, and each subsequent element represents a more recent operation. In this sense the path elements can be likened to taxonomic identifiers. The species {Animalia;Mammalia;Hominidea;Homo} and {Animalia;Mammalia;Hominidea;Pan} are more closely related to each other than to {Animalia;Mammalia; Cervidea;Rangifer}** because they share more codes at the start of their classification. Similarly, the paths {2;4;4} and {2;4;6} are more closely related to each other than they are to {2;3;5}.
The messy reality of data trees.
Although you may agree with me that in theory the data tree approach is solid, you may still get frustrated at the rate at which data trees grow more complex. Often Grasshopper will choose to add additional elements to the paths in a tree where none in fact is needed, resulting in paths that all share a lot of zeroes in certain places. For example a data tree might contain the paths:
{0;0;0;0;0}
{0;0;0;0;1}
{0;0;0;0;2}
{0;0;0;0;3}
{0;0;1;0;0}
{0;0;1;0;1}
{0;0;1;0;2}
{0;0;1;0;3}
instead of the far more economical:
{0;0}
{0;1}
{0;2}
{0;3}
{1;0}
{1;1}
{1;2}
{1;3}
The reason all these zeroes are added is because we value consistency over economics. It doesn't matter whether a component actually outputs more than one list, if the component belongs to the 1:N, 1:N', or N:N' groups, it will always add an extra integer to all the paths, because some day in the future, when the inputs change, it may need that extra integer to keep its lists untangled. We feel it's bad behaviour for the topology of a data tree to be subject to the topical values in that tree. Any component which relies on a specific topology will no longer work when that topology changes, and that should happen as seldom as possible.
Conclusion
Although data trees can be difficult to work with and probably cause more confusion than any other part of Grasshopper, they seem to work well in the majority of cases and we haven't been able to come up with a better solution. That's not to say we never will, but data trees are here to stay for the foreseeable future.
* This is not something we hit on immediately. The very first versions of Grasshopper only allowed for the storage of a single data point per parameter, making operations like [Loft] or [Divide Curve] impossible. Later versions allowed for a single list per parameter, which was still insufficient for all but the most simple algorithms.
** I'm skipping a lot of taxonometric classifications here to keep it simple.…
Added by David Rutten at 2:22pm on January 20, 2015