Description Update.

You can find a set of videos with examples and tutorials on Ivy on my Vimeo Chanel.

Additionally if you are interested in the research behind Ivy you can read these two papers.

Description.

This is the most recent release of my plug-in for mesh analysis, segmentation and unrolling inside the Grasshopper environment.

Ivy uses notions and algorithms from Graph Theory and applies them towards mesh geometry exploration. In order to enable the use of graph theory specific algorithms, a new custom data type was created. The **MeshGraph** is an abstract construct that combines the geometric characteristics of the mesh with sets of linked data containers. The data containers that can be visualized as the mesh faces are the nodes of the graph and the links between them are the graph edges. The graph edges can be visualized as the mesh topological edges.

The tools packaged with Ivy are organized inside nine categories:

· 1| Mesh Graph contains components that deal with constructing and decomposing MeshGraphs.

· 2| Weight Graph houses a set of components for adding additional data to a MeshGraph. This is important for the tree making algorithms in the next sections. A MeshGraph can have both node and edge weights specified for each of its nodes and/or edges. The weights are added to the MeshGraph as floating point numbers between 0 and 1. All values are normalized to that interval. Any kind of geometrical/non geometrical property of any object residing in the Grasshopper environment that can be expressed as a number, can be used as a node or edge weight. The tools in this category are in fact a sum of presset ways to add the weight information to the MeshGraph. The most important here are the two components facilitating the insertion of custom numeric weight data into the MeshGraph.

· 3| Primary segmentation - Tree Graph. This sections houses the tree making tools, a series of algorithms that make use of the weight data assigned with the tools of the previous section. Essentially all the tools in this category make tree MeshGraphs from simple MeshGraphs. In graph theory, a tree is an undirected graph in which any two vertices are connected by exactly one path. In other words, any acyclic connected graph is a tree. Tree making algorithms are the heart of this plug-in as any important operation performed with Ivy (like unrolling a mesh) depends on the MeshGraph being a tree. The section contains components each with different algorithms for creating MeshGraph trees.

· 4| Secondary Segmentation makes use of the special properties of a tree MeshGraph to split the graph and its underlying mesh. The splits happen based on the weights stored with the MeshGraph edges or nodes and the rules embedded in the tree parsing algorithms in the components housed in this section.

· 5| Iterative segmentation contains one algorithm for improved mesh feature detection and segmentation. The K-Means algorithm.

· 6| Special Segmentation contains the unrolling component that is in essence another segmentation of the MeshGraph based on the overlaps produced by the mesh in its flat state. Another component housed here is the shortest path component. This extracts segments of mesh based on the shortest route (in weight terms) between 2 or more faces.

· 7| Fabrication contains tools that take care of the flat fabrication for the unrolled MeshGraph parts. Different custom or standard glue flaps can be created here.

· 8| Mesh Info. This section contains components that deal directly with the mesh and extract information to be used as edge weight for the tools in section 2. New tools here are the orange peel edges (a great way to segment a mesh for unrolling in the least number of parts) and mesh edges a tool for extracting the topological edges of a mesh depending of their use in a MeshGraph.

· 9| The last section contains miscellaneous tools to interact with the MeshGraphs and two tools to create mesh creases and structures based oh the MeshGraph hierarchy. Starting from version 0.92 you can use Ivy to create mesh weaves. Have a look at the exmples to see some of the posibilities.

Test first the functionality of Ivy tools with simple meshes to get a feel for how each component operates. Work your way towards more complex meshes (with over 1000 faces) bearing in mind that a large number of faces can exponentially increase the computation time from milliseconds to minutes.

I have tested this project, but it is the first release and it might contain still bugs as it is only an alpha version for now. Please use it "as is", it does not come with warranties. I spent a lot of time developing the logic and implementing it, please give credit where credit is due.

To install:

- In Grasshopper, choose File > Special Folders > Components folder. Save the gha and dll file there.
- Right-click the file > Properties > make sure there is no "blocked" text
- Restart Rhino and Grasshopper

Additionally I included a number of comented examples showcasing allmost all components and different use scenarios. If you are interested in simple mesh unrolling the first example should suffice.

Update| There is now an Ivy manual. Download and use with the laltest version of IVY.

- Andrei Nejur

- Category: