Introduction

This article will consist of about 3~4 chapters, assuming the following readers

1. who are interested in Rhinoceros+Grasshopper
2. who want to deepen their understanding of internal processing when using Rhinoceros+Grasshopper
3. who want to use Rhinoceros+Grasshopper for their own extension for business, research, hobby, etc.
4. who want to design and play with metamaterials

The purpose of this article, the second chapter, is to understand the parts of Grasshopper that you should understand but do not see comprehensively explained (from the big picture to the internal processing) in order to extend Grasshopper on your own.

There are many excellent learning contents out there, so we will mainly explain the basics in depth on the assumption that you can refer to those contents.

Since we will be talking about something close to implementation, it will be easier to read if you know some programming language, preferably C#.

What is Grasshopper?

Rhinoceros is a 3D CAD as mentioned in the previous chapter, and Grasshopper is a plug-in that comes with it by default.

Using a visual programming environment called the Node Editor, it is possible to achieve complex/advanced processing controlled by programs, which is difficult to do with Rhino alone.

The node editor is a visual programming environment that allows for complex/advanced processing controlled by a program, which is difficult to achieve with Rhino alone.

What does Grasshopper make happy?

The joys of using Grasshopper are many and varied, but we often see people who are reluctant to learn Grasshopper because they don't understand what actually makes them happy (or they see a strangely complicated UI screencast, etc.).

I will try to break down the elements as much as possible and introduce them to you.

Complex processing can be achieved with no code!

The node editor itself is explained in the Wiki, but in addition to being a node editor, the detailed specifications described below make it possible to realize complex processing without writing a program.

While its unique data structure and algorithms make it possible to build intuitive and complex processes, its side effect is that it is uniquely difficult to understand, and overcoming this is a barrier to learning.

One point to note is that Grasshopper does not allow loops in node connectivity, so recursive processing is not directly possible (!). However, the data structure and processing rules described below allow for processing that is equivalent to recursive processing.

Parametric processing construction is possible!

As mentioned in the previous section, Rhino is a CAD system that does not have a history in principle, so it is not possible to change the parameters of a process that has been performed in the past.

In Grasshopper, on the other hand, a network of processes with parameters is created, so that each time a parameter is updated, the process is executed again with the updated parameters.

The kind of precise geometry editing that is done interactively in Rhino is not suitable for Grasshopper (although it can be done with a great deal of effort),

• Geometry study in the verification phase
• Shape generation with optimization in mind

However, Grasshopper is very powerful for applications where you want to change parameters after the fact, such as shape study during the verification phase, shape generation for optimization, etc.

Can handle high volume/complex processing!

By default, most of the individual operations that can be performed by Grashopper can also be performed on Rhino.

So, is it possible to do something like "create a circle with radius r0+0.1*i at each point p_i obtained by dividing a given curve into n equal parts" by hand in Rhino?

I can do this by running the Circle command n+1 times, increasing the radius by 0.1 after getting n+1 points from the Curve with the Divide command.

In Grasshopper, this can be done with as few as four components, and each variable can be changed later. The same is true for more complex examples. Glad to hear it.

Easy reuse of assets!

Grasshopper provides a mechanism to define inputs and outputs for a series of processes or files you create, making them reusable as nodes.

This is useful for team collaboration and modularization of frequently used processes.

Extensibility, active community

As with Rhino in the previous chapter, flexible extensibility is ensured, and various assets are actively disclosed in communities such as Forum and Food4Rhino.

Various extensions are possible with add-ons that are basically developed in C#, and external libraries can also be used.

In addition, because Grasshopper is built by combining nodes, a variety of applications across industries and technical domains are being created daily by combining add-ons.

Understanding Grasshopper

Understanding Grasshopper (1): Basic Components

In order to understand the processing taking place in Grasshopper, it is important to understand

• Goo
• Param
• Component

In a nutshell, Grasshopper is

• A Goo that holds data.
• Goo is passed through Param, which can hold the Goo in a certain data structure, while
• Component executes the process.

I will explain the three.
Understanding these three functions and their relationship should give you an idea of the overall picture of the processing that takes place in Grasshopper.

Goo

GH_Goo<T> and GH_ GeometricGoo<T> and other IGH_ Goo<T>, which inherit from abstract classes that implement interfaces, By implementing a Goo class that specifies the type T to be handled within Grasshopper, it functions as a wrapper class for type T that provides functionality for handling within Grasshopper.

The functions that Goo has are as follows.

• Functionality for holding and externally accessing type T values.
  The values GH_Goo and GH_GeometricGoo hold values of the type specified by generics in the m_value field, which can be accessed with the Field property.
• Interconversion functionality with other Goo and classes.
  The CastTo and CastFrom methods can be implemented to provide type conversion functionality between different Goo This allows Grasshopper to provide type conversion functionality between different Goo types.
  This allows Grasshopper to build processes without explicitly being aware of the need to convert between different types.
  (e.g., even if you connect an integer value to an input port that expects a double value for a component, internally GH_Intger(GH_Goo<int>) is converted to GH_Number(GH_Goo<double>) via the CastTo method)
• Shape transform function (GH_GeometricGoo<T>).
  Rhino and Grasshopper perform many shape transformations, including affine transformations.
  Transform method and Morph methods by implementing them, By implementing the [Transform]() and [Morph]() methods, it is possible to make geometry data that is not supported by default compatible with Rhino and Grasshopper's various geometry transformation functions.

Param

GH_Param<T> and GH_PersistentParam<T >, [IGH_Param<T>](https:// developer.rhino3d.com/api/grasshopper/html/T_Grasshopper_Kernel_IGH_Param.htm), which inherits from an abstract class that implements an interface (T is constrained to Goo) and can be used by one or more It holds one or more Goo in a data structure called GH_Structure<T>. The main function is to hold one or more Goo in a data structure called [GH_Structure<T>] () and pass it from one component to another.

It is non-intuitive, but everything circled in red in the image is a Param, which is handled in the UI in the following ways

• Floating: The UI itself has inputs and outputs just like a component and passes goo to and from it.
• Input: Serves as an input port for the Component and passes Goo to and from it
• Output: Functions as an output port of the component and passes goo to and from it

There are three types of Input and Output. Basically, there is no problem in understanding that they function as Input and Output.

Component

This is a node in the node editor and is basically implemented by inheriting from the GH_Component class. It is implemented by inheriting from the [GH_Component]() class. It is a node in the node editor, basically implemented by inheriting from the SolveInstrance class, which is a real processing method that combines the information passed from the input Param with the appropriate combination. Component_SolveInstance.htm) and passes the processing results to the output Param with an appropriate data structure.

Understanding Grasshopper (2): Processing Flow and GH_Structure

The biggest hurdle in learning Grasshopper is often said to be the data structure used to hold information in Param, [GHStructure<T>](https://developer.rhino3d.com/api/grasshopper/html/T Grasshopper_Kernel_Data_GH_Structure_1.htm), and this data structure and certain rules determine the behavior of the Component.

Basically, it is often explained by likening it to a tree structure such as DataTree, but I personally think there are misunderstandings and difficulties in understanding due to this, so I will try to give a concrete explanation closer to the internal process.

What is GH_Structure?

First, in a nutshell, GH_Structure is "like a dictionary ordered by GH_Path that holds a list of Goo's with GH_Path (multiple integer values like {0;0;1}) as the key.

GH_Path can be ordered by comparing large and small values, starting with the integer value on the left.

Example: {0;0;0} < {0;0;1} < {0;1;0} < {1;0;0}

Handling of GH_Structure within Component

Component is the same as each input Param's

• GH_Structure
• Data access settings (see below for details)
  • item: Passes one Goo in GH_Structure to SolveInstance
  • list：List of Goo corresponding to one GH_Path in GH_Structure is passed to SolveInstance
  • tree: GH_Structure itself is passed to SolveInstance

Based on the "GH_Structure", the SolveInstance method decides what combination of input values to execute based on a certain rule, processes it, and outputs the result.

The rule is as follows (I describe item and list because the data access case of tree is simple and not so common). There are several ways to explain this, but I will try to make it easy to understand and avoid misunderstandings.

**Assumptions

• The GH_Structure of each input Param holds a list of Goo's (this list of Goo's is called a branch for convenience) with GH_Path as the key, which is sorted in ascending order by GH_Path.
• Each input Param has its data access settings set to item or list.
• Each input Param may have different number of branches (= number of key GH_Paths) and number of items in the branch.

(1) Mapping between branches of GH_Structure of each input Param.

Take the nth branch from each GH_Structure. If the number of branches is less than n, the last branch is taken. For convenience, we refer to this as a branch set.

As a result, a branch set is defined for the number of branches in the GH_Structure with the largest number of branches.

②Divide the Goo in the branches into units to be passed to SolveInstance.

For each branch in the branch set, "If the data access is list, the processing unit is the list of all Goo's in the branch. If data access is item, each Goo in the branch is the processing unit.

As a result, in the case of a list, one processing unit is created, but in the case of an item, a processing unit is created for the number of elements in the branch.

3) Correspondence between processing units.

Now that the branch set has been defined, a processing unit has been defined for each branch in the branch set. In contrast to this,

The nth processing unit is taken from each branch. If the number of processing units in a branch is less than n, the last processing unit is taken.

This rule is used to match the processing units. This combination becomes the value combination passed to SolveInstance.

Example of the entire process

SolveInstance is run for each blue line connecting the left and right sides, and the result is output.

The Tree structure is irrelevant to the correspondence of the processes.

As you can see from the above rule, GH_Path only works as a key to sort branches.

Since GH_Path is a set of integers, it is often visualized and explained as a tree structure, including official ones, but in a setup like the one below, for example, you would expect the correspondence to follow a tree structure, but it does not.

How to deal with GH_Structure

If you understand the processing rules as described above, all you need to do to achieve the desired processing is to create a GH_Structure with the correct structure and input it into the component.

Grasshopper provides many components for GH_Structure operations by default, and also publishes useful add-ons such as TreeSloth.

It takes some getting used to realize algorithms defined using recursive processing with GH_Structure handling, but once you get used to it, you can realize a wide variety of processing with each Param's data access settings and input GH_Structure structure.

In C# component development, which will be discussed in the next chapter, you can of course write recursive processing in any way you like within the component.

Recommended learning contents

If you understand the principles mentioned in this chapter, it would be efficient to learn by watching and copying Grasshopper files and videos of people who have mastered the language.

There are a large number of excellent videos and blogs available, so there is no shortage of content.

As with Rhino, the official Forum and Food4Rhino are essential.

• HIROSHIMA DESIGN LAB - Introduction to Grasshopper](https://www.youtube.com/watch?v=Wm7-8eJzxXU&list=PLPnyFn_afm-iXUYKgMoa1isoEwrFgjOi3)

Good for an introduction to Grasshopper from scratch, from how to look at the UI to basic operations.

• Official Tutorials](https://www.grasshopper3d.com/page/tutorials-1)

It has a lot of contents.

• Rhinoceros Forums](https://discourse.mcneel.com/)

Most of the things I have problems with have been asked here at least once. If you ask a question in English, you will get an immediate answer from a strong person or developer.

• Food4Rhino

Various assets are actively shared.

• Parametric Design with Grasshopper, Revised and Updated, The Grasshopper Cookbook for Architecture/Products 2%97%E8%A3%9C%E6%94%B9%E8%A8%82%E7%89%88-%E3%83%97%E3%83%AD%E3%83%80%E3%82%AF%E3%83%88%E3%81%AE%E3%81%9F%E3%82%81%E3%81%AE%E3%80 81Grasshopper%E3%82%AF%E3%83%83%E3%82%AF%E3%83%96%E3%83%83%E3%82%AF/dp/4802511213/ref=sr_1_1?__mk_en_JP=%E3%82%AB%E3%82%BF%E3%82 AB%E3%83%8A&crid=JBBV0I3M68Z8&keywords=grasshopper&qid=1680747916&sprefix=grasshoppe,aps,158&sr=8-1)

This book contains careful and developed content, and most importantly, it contains many cool and motivating examples!

• Grasshopper API

Conclusion

Although this is a long preamble to start the implementation, this chapter has provided an overview of useful knowledge for development around Grasshopper. An understanding of this area will make the use of Grasshopper and the development of add-ons much smoother.

In the next chapter, we will discuss Grasshopper add-on development, including the Goo and Param extensions covered in this chapter.