History of Grasshopper
Origin: Grasshopper was created by David Rutten at Robert McNeel & Associates.
Why Grasshopper?: Rhino 4 initially had a basic history feature built-in, which allowed automatic updates of certain modelling steps. However, this history was implicit, meaning it was recorded as you went along without extra overhead. While this was useful, it had limitations. For instance, the history tree was hidden from the user, and adjusting the behaviour or properties of different history stages was challenging. Additionally, once a surface existed, changing Loft settings required recreating the surface and breaking downstream history records.
Explicit History: Grasshopper addressed these limitations by allowing users to construct their own history tree or definition of the procedure used to construct objects. This unique visual and interactive approach made it easy to learn, even for those without previous programming experience.
In Grasshopper, data flow is a fundamental concept that governs how information moves between components. Let’s break it down:
- Components:
- Grasshopper consists of various components, each representing a specific operation or function. These components can be mathematical operations, geometry manipulations, or custom scripts.
- Components are connected on the canvas by wires. These wires carry data from one component to another.
- Data Types:
- Grasshopper supports different data types, including:
- Numbers: Integers, decimals, etc.
- Vectors: Representing directions or forces.
- Points: Coordinates in 3D space.
- Curves, Surfaces, and other geometric entities.
- Text, Booleans, and more.
- Each component expects specific data types as input and produces specific data types as output.
- Grasshopper supports different data types, including:
- Data Flow:
- When you connect components with wires, you establish a data flow. Data flows from the output of one component to the input of another.
- Components can have multiple inputs and outputs. The order of connections matters.
- For example:
- If you have a component that calculates the sum of two numbers, you connect two number components (inputs) to it. The result flows out as an output.
- Similarly, if you have a curve component, you connect points or vectors to its input to create the curve.
- Tree Structure:
- Grasshopper organizes data in a hierarchical structure called a tree.
- A tree can have branches (sub-lists) containing data. For example, a list of points can be organized into branches, where each branch represents a separate set of points.
- Components can handle data at different levels within the tree structure.
- Data Matching:
- Components automatically match data based on their structure. If you connect two lists of points, Grasshopper ensures that each point from one list corresponds to the same index in the other list.
- Data matching can be explicit (using components like “Merge” or “Sift”) or implicit (handled by Grasshopper).
- Streamlining Flow:
- Organize your canvas logically. Place related components close to each other.
- Use panels to display data or add comments for clarity.
- Consider using data trees intentionally to manage complex data structures.
Remember that data flow in Grasshopper is dynamic. As you adjust parameters or change inputs, the data flows through the network, updating the results. Experiment, explore, and enjoy the creative possibilities!
Data Tree
Let’s dive deeper into the concept of data trees in Grasshopper.
- What Are Data Trees?
- A data tree is a hierarchical structure used to organize and manage data within Grasshopper.
- Think of it as a branching system where data is grouped into levels or branches.
- Each branch can contain one or more items (such as points, curves, or numbers).
- Why Use Data Trees?
- Data trees allow you to handle complex data relationships and structures.
- They are essential when dealing with multiple inputs or outputs in components.
- By organizing data into branches, you maintain context and preserve relationships.
- Tree Structure:
- A data tree resembles an inverted tree, with the root at the top and branches extending downward.
- Each branch represents a list of data items.
- For example:
- A list of points can be organized into branches, where each branch corresponds to a different set of points.
- If you have multiple curves, each curve can be in its own branch.
- Accessing Data:
- Components in Grasshopper operate on data at specific levels within the tree.
- You can access data by specifying the branch and item index.
- For instance:
- To access the third point in the second branch, you’d refer to it as
DataTree[1][2].
- To access the third point in the second branch, you’d refer to it as
- Tree Operations:
- Grasshopper provides components for manipulating data trees:
- Merge: Combines branches into a single list.
- Split: Splits a list into branches.
- Shift Paths: Adjusts the hierarchy.
- Flatten: Converts a tree into a flat list.
- Tree Statistics: Analyzes the structure.
- Grasshopper provides components for manipulating data trees:
- Managing Data Flow:
- When connecting components, ensure that data flows correctly through the tree.
- Use Path Mapper or Tree Branch components to control data paths.
- Understand how components handle data matching (matching indices or paths).
- Common Use Cases:
- Parametric Design: Data trees enable parametric modelling by maintaining relationships between inputs and outputs.
- Nested Structures: Represent complex assemblies, grids, or nested geometries.
- Branch-Specific Operations: Apply different operations to specific branches.
Remember that mastering data trees takes practice. Experiment with different scenarios, explore Grasshopper’s components, and enjoy the flexibility they offer! 🌿🌟
Exploring the Next Frontier: Grasshopper 2.0
The world of computational design is abuzz with the latest release from McNeel—the alpha version of Grasshopper 2.0. As a complete rewrite of the beloved Grasshopper 1.0, this new iteration promises to revolutionize the way designers and architects approach their projects.
A Fresh Start with Grasshopper 2.0 Grasshopper 2.0 is not just an update; it’s a total overhaul. The transition from 1.0 to 2.0 means starting from scratch, as there is little continuity between the two versions. This means existing files, settings, and plugins from GH1 will not carry over directly to GH2. While this may seem daunting, it’s a necessary step to accommodate the new multi-threaded architecture that GH2 introduces.
Why Multi-threading Matters The move to multi-threading is a game-changer for Grasshopper 2.0. It allows for concurrent calculations, which can lead to faster processing times, especially for independent calculations. However, don’t expect your 16-core machine to run 16 times faster just yet. The new codebase is still in its infancy and will need time to reach the level of optimization that GH1 achieved over a decade.
The Intangible Benefits of Early Adoption For those willing to dive into the alpha phase of GH2, there are unique opportunities to shape the future of the software. Your feedback can influence your development, and you’ll gain proficiency ahead of your peers. However, for production work, it’s advisable to stick with GH1 until GH2 proves to be a viable alternative.
Innovative Features to Look Forward To Despite its unfinished state, GH2 introduces some exciting features:
- Functions as Data Types: Functions now stand-alone, freeing them from the confines of the Graph Mapper.
- Meta Data Tagging: Organize your data with ease by attaching metadata to values within your Grasshopper document. This feature simplifies what was once a complex task in GH1.
Taking GH2 for a Spin If you’re curious about GH2, you can install it via Rhino 8 Wip’s _PackageManager command and test it out when you have some free time. If it’s not for you, simply uninstall and check back in a few months.
Documentation and Support Be sure to explore the Grasshopper 2.0 Documentation available through the Help menu. It’s a work in progress but contains valuable content and examples to get you started.
