Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
The relationship between: the compression equilibrium shape, the thrust network or the "thrust diagram" (G); its planar projection (primal grid Γ, or the "form diagram"); and the reciprocal diagram (dual grid Γ*, or the "force diagram" ).
The workflow of RV2 is based on the theoretical framework of TNA, which can be broken down into 7 main steps.
A Pattern
describes the topology of the FormDiagram
. A Pattern
is a collection of vertices interconnected by lines or "edges". RV2 provides several methods for generating a Pattern
and various mechanisms to modify and refine its geometry.
In this step, additional information is added to the Pattern
, such as identification of the support vertices and refinement of the geometry of the unsupported boundaries.
Once the support vertices have been defined and the boundaries have been properly modified, the FormDiagram
can be created from the Pattern
.
Once the FormDiagram
has been successfully created, the ForceDiagram
can be created. In its initial state, the ForceDiagram
is the topological dual of the FormDiagram
; the two diagrams are not yet reciprocal.
In order for the FormDiagram
and the ForceDiagram
to be reciprocal, the edges of one diagram needs to be perpendicular to the corresponding edge in the other diagram. Horizontal equilibrium solver iteratively repositions the vertices of the FormDiagram
and/or ForceDiagram
until the perpendicularity criteria (within desired angle tolerance) is met.
Once the FormDiagram
and ForceDiagram
are reciprocal (in other words, in horizontal equilibrium), the geometry of the ThrustDiagram
can be computed. The ThrustDiagram
is equivalent to the FormDiagram
with the updated z coordinates of its vertices (therefore updated self-weight at each vertex).
Given a desired target height of the eventual ThrustDiagram
, vertical equilibrium solver iteratively re-scales the ThrustDiagram
in the z-axis, until the highest vertex of the ThrustDigram
lies at the desired target height.
Once the vertical equilibrium has been computed, the three diagrams can be interactively modified by the user to continue form finding explorations.
There are two ways of accessing the functions and features of RV2 using the graphical user interface:
RV2 dropdown menu (all functionalities and features available)
RV2 toolbar (most functionalities and features available)
Any of the three methods can be used to use RV2, and the interface of choice is simply up to the user's preference.
Note that the menu and toolbar are only available for Rhino on Windows.
Using a JSON config file, commands are then organised as menu items and toolbar buttons and compiled into a Rhino User Interface file (*.rui
). This is the file you loaded into Rhino during the installation process.
By initialising RV2, the COMPAS functionality is loaded and the commands are made available. At the same time, a server is started to run commands that require specific CPython functionality "in the cloud" through remote procedure calls.
The RV2 menu is organized in the sequential order (0, 1a, 1b... 6, from top to bottom) of the steps of the RV2 workflow. The RV2 menu includes all available functions and features of RV2.
The RV2 toolbar is organized in the sequential order (0, 1a, 1b... 6, from left to right) of the steps of the RV2 workflow. The RV2 toolbar includes most of the available functions and features of RV2. It is the "condensed" kit of parts for the entire RV2 workflow, and offers the user a quick access through the command line, to all the key features of RV2.
This first tutorial highlights and describes the main features of RV2. This tutorial is intended to be a “quick start” guide of the main steps and procedures of the RV2 workflow. Specific parameters and optional features will not be addressed in detail. Further information about each of the procedures, methods and various optional parameters involved in each of the steps will be presented and discussed later in the week.
This first step initiates the RV2 engine, imports all the relevant packages and activates compas_cloud
server. The startup window also provides various links to useful information, such as the online documentation, tutorials, tutorials and terms of use. By clicking “YES,” you acknowledge that you have read and understood the Terms and Conditions, and the Data Donation Agreement.
A Pattern
is a collection of lines that define the topology of the form diagram. In this step, the user can create a Pattern
from:
Rhino lines
Rhino mesh
Rhino NURBS surface (untrimmed)
skeleton
triangulation from boundary curves
quad mesh from boundary curves and point features
In this tutorial, we will use a simple orthogonal surface, which can be created through the Rhino command, “Rectangular plane: corner to corner.” By choosing two corners, create a planar surface that is a square in plan.
In the RhinoVAULT 2 drop down menu, select “Create pattern”, then “From Surface.” Select the the surface in the viewport.
This command will generate a Pattern
from the input surface, using the UV mapping of the surface. The user has the option to enter values for “U” and “V.” For this tutorial, we keep the U and V to their default values of 10.
RV2 provides various mechanisms for modifying the geometry of the pattern, such as moving vertices, changing attributes of vertices and edges, smooth and relax. These features will not be used in this tutorial.
Once a Pattern
object has been generated, the boundary conditions will need to be defined. In RV2, the boundary conditions include: 1) identifying the supports (vertices of the structure where reactions are allowed); 2) defining and updating the openings; and 3) loading parameters and conditions.
In the RhinoVAULT 2 drop down menu, select “Define Boundary Conditions”, then “Identify Supports.”
The command will provide two options, to select or unselect vertices to define them as supports or not. Click 'Select'.
In this tutorial, we use the mode ByContinuousEdges, and select one edge on the left boundary and on edge on the right boundary of the pattern. Once the two edges are selected, press Enter, then all the vertices along that boundary from corner to corner, will be automatically selected (supports are shown in red).
The second step of defining boundary conditions involves updating the geometry of the openings. In this tutorial, the two boundaries at the top and the bottom are the openings (the edges are on the boundary of the pattern but have no support vertices along them).
Because openings have no supports (i.e. reaction or external forces), they cannot be straight; openings need to curve inward towards the center of the pattern, so that horizontal equilibrium can be resolved.
In the RhinoVAULT 2 drop down menu, select “Define Boundary Conditions”, then “Update Openings.”
If there are straight openings found in the pattern, an automatic sag of 5% of the span of the opening will be imposed. Per opening, the user has the option to enter a desired amount of sag, as a percentage of the span of the opening.
In this tutorial, sag of 10% is applied to opening 1, and sag of 20% is applied to opening 0.
Once the boundary conditions have been defined, the Pattern
can now be converted into a FormDiagram
.
In the RhinoVAULT 2 drop down menu, select “Create FormDiagram.”
If the creation of FormDiagram
is successful, it will be displayed with green vertices and edges. The ThrustDiagram
is also automatically created (displayed in light green), the geometry of which is equivalent to the FormDiagram
at this initial, vertically un-equilibrated state.
Once the FormDiagram
has been created, the ForceDiagram
can now be created.
In the RhinoVAULT 2 drop down menu, select “Create ForceDiagram.”
The ForceDiagram
will be automatically drawn to the right (+x) of the FormDiagram
. The initial ForceDiagram
is the topological dual of the FormDiagram
. The two diagrams are not yet reciprocal, meaning that the corresponding edges in the diagrams are not perpendicular to the other.
When the diagrams are not yet reciprocal (in other words, not perpendicular-ised or “equilibrated”), the edges with angle deviations above the defined angle tolerance will be displayed. The dots displaying the angle deviations are visual cues for the user, indicating that horizontal equilibrium has not yet been resolved.
Once the FormDiagram
and ForceDiagram
have been created, the horizontal equilibrium algorithm perpendicular-ises either or both diagrams, which converts them from dual to reciprocal diagrams.
In the RhinoVAULT 2 drop down menu, select “Horizontal Equilibrium.”
Under “Alpha” option, the user will be able to select a value that determine which of the two diagrams will have more weight during the perpendicular-isation process. Default is “form100,” which only allows the ForceDiagram to update in its geometry. User can also enter the number of iterations. Default number of iterations is 100.
If horizontal equilibrium has been found, meaning that all the corresponding edges now have angle deviations that are below the defined angle tolerance, the two diagrams should no longer have any dots displaying the angle deviation values, as shown below.
With the FormDiagram
and ForceDiagram
now reciprocal, the coordinates of the ThrustDiagram
can be iteratively computed based on a desired z-max (target height) value.
In the RhinoVAULT 2 drop down menu, select “Vertical Equilibrium.”
The user can manually enter a desired value for the target height of the vault, and the number of iterations for the algorithm. Default number of iterations is 100.
If the vertical equilibrium is successfully computed and found, the new ThrustDiagram
will be displayed, now with updated z coordinates.
Under “Settings,” various global parameters and visualisations options can be modified.
There are several features that facilitate analysis and enhance visualisation.
In Settings > RV2 > show, checking "Forces" draws the edges of the ForceDiagram
with a color gradient from blue, green to red, based on its the length (the horizontal force in the corresponding edge of the ThrustDiagram
). The corresponding edges in the FormDiagram
are also displayed with the same color, which makes the two diagrams much more legible and discernible (blue means smaller horizontal force, red means greater horizontal force).
With “Display Pipes,” the edges of the ThrustDiagram
can be visualised with pipes, the radii of which are proportional to the internal forces.
During the RV2 workflow, there may have been unintended modifications to the geometry of the diagrams, such as accidentally moving the vertices. In such cases, running the RV2redraw
command will simply redraw the three diagrams without executing any command.
When a work session has ended, and the user wishes to start a new file/design, RV2clear_all
command will delete all existing diagrams in the work session.
During any stage of the RV2 workflow, the three diagrams can be saved as .rv2 files. These files can be opened in the future, and the user can resume working with existing diagrams and resuming work where the user left off during the last session.
The easiest way to install RhinoVAULT 2 is to use the executable installer.
RhinoVAULT 2 works both on Mac and Windows. However, there is currently no way to ship a UI with a Python-based CommandPlugin for Rhino on Mac. Therefore, to use RV2 using the pre-compiled UI, you have to install RV2 for Rhino 6+ on Windows.
Open Rhino and run the command EditPythonScript
once, then exit Rhino (this will initialize some internal Rhino folder structure which is necessary for the installation of RV2).
Download latest RV2 installation file from https://github.com/BlockResearchGroup/compas-RV2/releases
Run the installation file. If you see following prompt, click on More info
then choose Run anyway
After the installation interface shows up, click on the Install RV2
button, then choose a location to install RV2 on your computer.
RV2 is a Rhino plugin. It is not software. We just need an installation location to set up some of the dependencies for the plugin.
Therefore, you can choose any folder for the installation, as long as there are no spaces in the installation path!
Paths likeD:\Program Files\...
will fail to install.
However, please, don't use your "Program Files" folder for the installation process since this requires special admin privileges. Instead, use something like:
C:/Tools
C:/RhinoVault2
C:/DF2020
C:/Users/username/Documents
C:/Users/username/Desktop
The installation usually takes 1~2 minutes. After the progress bar finishes, click Yes
twice in User Account Control.
The installation is successful if you see this message:
Note that you have to close the installer window after the installation.
In the top menu, go to Tools > Toolbar Layout
.
In the pop-up window, click File > Open
.
Select the file RV2.rui
and click Open
.
Tick RV2
in the Toolbars section.
The RV2 menu and toolbar will now both appear in user interface.
To check that everything worked, click the Initialise RV2
menu item or toolbar button. You will be asked to accept the "Terms and Conditions" and "User Agreement" (just click Yes
:) after which the welcome screen should disappear.
If the initialization step fails, please file an issue on the RV2 issue tracker and we will help you as quickly as possible.
If Rhino says Command not found: -_RV2init
, please type EditPythonScript
to open the script editor and restart Rhino. Then try the initialisation again.
Funicular form finding based on the COMPAS framework
The Rhinoceros® plug-in RhinoVAULT, developed by Dr. Matthias Rippmann at the Block Research Group at ETH Zurich, emerged from research on structural form finding using the Thrust Network Analysis (TNA) approach to intuitively create and explore compression-only structures.
Using reciprocal diagrams, RhinoVAULT provides an intuitive, fast funicular form-finding method, adopting the same advantages of techniques such as Graphic Statics, but offering a viable extension to three-dimensional problems. Our goal is to share a transparent setup to let you not only create beautiful shapes but also to give you an understanding of the underlying structural principles.
Development of RV 1 has stopped. We developed the brand-new version, RhinoVAULT 2, based on the COMPAS framework. Happy form finding!
RhinoVAULT 2 (RV2) is an open-source research and development platform for funicular form-finding built with COMPAS, a Python-based framework for computational research and collaboration in Architecture, Engineering, and Digital Fabrication.
RV2 is a Rhino plugin that replaces RhinoVAULT for Rhino versions 6 and above. Unlike RhinoVAULT, RV2 no longer relies on Rhino for its computational implementation. Instead, it is built entirely with open source packages from the COMPAS ecosystem and will, therefore, be available not only for Rhino and Grasshopper, but also for Blender and other tools with a Python scripting interface, and ultimately even in the browser.
The core functionality of RV2 is based on the following COMPAS packages and can be used in any environment that supports Python.
Base data structures
File support
Numerical solvers
Geometry processing
Form, Force and Thrust Diagrams
Horizontal equilibrium
Vertical equilibrium
For the design of force patterns in Form Diagrams, we use
Pattern design based on topological features and placement of singularities in quad meshes.
Pattern design based on line skeletons.
Pattern design based on Constrained/Conforming Delaunay Triangulations.
CAD integration packages make this core functionality available in specific software like Blender or Rhino. The current release of RV2 provides only a plugin for Rhino (Blender and Grasshopper integration is under development and will be available soon):
Geometry and data structure conversions.
Drawing functionality.
Selections and interaction.
Remote Procedure Calls
Python based
Based on the COMPAS core framework and packages
Open source
Fully extendible and customisable
RV2 is currently implemented specifically for Rhinoceros 6. However, the core pipeline is set up flexibly without any dependencies to a specific CAD software; CAD software simply functions as the visualisation canvas and UI. Future releases will include implementations for other CAD software.
Furthermore, the UI menu is only available for Rhino6 on Windows. The plugin works on Mac but has to be used from the Rhino Command Prompt (no menu or toolbar available for Mac).
The development of RV2 is hosted on Github and is entirely open source, and we very much welcome your feedback. Please use the issue tracker of the RV2 GitHub repository to submit information about bugs, technical problems, or feature requests.
Thrust Network Analysis (TNA), a methodology for generating compression-only vaulted surfaces and networks was developed by Prof. Philippe Block as part of his PhD (2009) at MIT, under the guidance of Prof. John Ochsendorf. The method finds possible funicular solutions under gravitational loading within a defined envelope. Using projective geometry, duality theory and linear optimization, it provides a graphical and intuitive method, adopting the same advantages of techniques such as graphic statics, but offering a viable extension to fully three-dimensional problems.
Block P. and Ochsendorf J. , Journal of the International Association for Shell and Spatial Structures, 48(3): 167-173, 2007.
Block P. , PhD dissertation, Massachusetts Institute of Technology, Cambridge, MA, USA, 2009.
An installation procedure for those who want to use RV2 in combination with other tools and environments.
Use a "manual" install if you want to be able to modify the conda
environment used by RV2, for example to install additional packages, or if you simply want to be able to use the latest, unreleased version of the code.
1.4.7 is the latest released version of RV2. You can return to this environment at any time and install a specific version of RV2.
Finally, we have to load the UI in Rhino. Please follow the instructions in Active Toolbar in Rhino
The Rhinoceros® plug-in RhinoVAULT, developed by Dr. Matthias Rippmann at the Block Research Group of ETH Zurich, emerged from research on structural form finding using Thrust Network Analysis (TNA) and was developed to facilitate the creation and exploration of compression-only, funicular structures.
Based on TNA, RhinoVAULT provides an intuitive method for funicular form finding, adopting the same advantages of techniques such as graphic statics, but offering a viable extension to fully three-dimensional problems. The designer can control the many degrees of freedom of highly indeterminate three-dimensional equilibrium systems to explore structural form.
Since its release in 2014, RhinoVAULT has been downloaded by more than 30.000 people, it was awarded in the category "Structure / Physics Formation" at ALGODeQ, an international competition for algorithmic design programs, and it has been used to design surprising free-form masonry vaults and shell structures all over the world.
Rippmann M., Lachauer L. and Block P. RhinoVAULT - Interactive Vault Design, International Journal of Space Structures, 27(4): 219-230, 2012.
Rippmann M. Funicular Shell Design: Geometric Approaches to Form Finding and Fabrication of Discrete Funicular Structures, Doctoral dissertation, Department of Architecture, ETH Zurich, 2016.
Open Rhino.
Type EditPythonScript
to open the Python script editor.
Close Rhino.
Run the installer again.
Some parts of Rhino's internal folder structure are only created after the Python script editor has been opened at least once.
Open Rhino.
Type EditPythonScript
to open the Python script editor.
Restart Rhino.
Initialise RV2 again.
Python Plugin commands are not automatically recognised...
It's possible that you have other broken python plugins installed previously that prevents RV2 from loading. To fix this problem, go to your rhino plugin folder and delete other plugins. The plugin folder location is: C:\Users\{YOUR_USER_NAME}\AppData\Roaming\McNeel\Rhinoceros\6.0\Plug-ins\PythonPlugins
or if you are using Rhino7:C:\Users\{YOUR_USER_NAME}\AppData\Roaming\McNeel\Rhinoceros\7.0\Plug-ins\PythonPlugins
This is a bug from Rhino side, whenever a user re-open another 3dm file, All Python Command Plugins including RV2 start to disfunction. So if you need to open a new file, you will have to always restart Rhino first.
This was due to failure to build Planarity
which is a dependency of COMPAS, it requires xcode
available on your Mac. Run the command below and try to install RV2 again.
In addition to the graphical user interface (menu and the toolbar), RV2 commands are directly accessible through the Rhino command line. Simply start typing RV2_...
in the Rhino command line, and you should see a dropdown list of all the available RV2 commands.
Accessing RV2 commands and features via the command line is available for both Windows and Mac.
RV2boundary_boundaries
RV2boundary_openings
RV2boundary_supports
RV2clear_all
RV2cloud_check
RV2cloud_restart
RV2cloud_shutdown
RV2file_open
RV2file_save_as
RV2file_save
RV2force_attributes
RV2force
RV2force_modify_edges
RV2force_modify_vertices
RV2force_move_vertices
RV2form_attributes
RV2form
RV2form_modify_edges
RV2form_modify_vertices
RV2form_move_vertices
RV2form_relax
RV2form_smooth
RV2init
RV2pattern_attributes
RV2pattern_delete
RV2pattern_from_features
RV2pattern_from_lines
RV2pattern_from_mesh
RV2pattern_from_skeleton
RV2pattern_from_surface
RV2pattern_from_triangulation
RV2pattern_modify_edges
RV2pattern_modify_vertices
RV2pattern_move_vertices
RV2pattern_relax
RV2pattern_smooth
RV2pattern_subdivide
RV2redraw
RV2settings
RV2thrust_attributes
RV2thrust_modify_vertices
RV2thrust_move_supports
RV2tna_horizontal
RV2tna_vertical
Each command has a corresponding xxx_cmd.py
file. All command files have the same structure. For example, one of the simplest commands is RV2redraw
, which is defined in RV2redraw_cmd.py
There are three ways to install RV2 on your computer.
If you just want to use RV2 as a plugin and want a setup that just works out of the box, you can simply use the installer.
Use a "custom" install if you want to be able to modify the conda
environment used by RV2, for example to install additional packages, or if you simply want to be able to use the latest, unreleased version of the code.
Follow a "dev" installation procedure if you want to contribute to the development of RV2.
An installation procedure for those who want to contribute to the development of RV2.
Latest released version of RV2 is 1.4.7. This version requires:
compas 1.14.1
compas_cloud 0.3.2
compas_tna 0.1.5
compas_skeleton 1.1.4
Use a "dev" install or "developer" install if you want to contribute to the development of RV2.
Use conda
to create a development environment, for example "rv2-dev", and install git
, python
, and cython
.
In the dev environment, use pip to install an editable, local version of RV2.
compas_rv2.datastructures
compas_rv2.rhino
compas_rv2.scene
Behind the menu items and toolbar buttons of the UI are the commands of a RhinoPython Command Plugin. The commands are defined in python scripts in compas_rv2/ui/Rhino/RV2/dev
. For example, RV2form_cmd.py
defines the command for creating an RV2 Form Diagram.
The Rhino plugin is implemented as a . In the current release, the following commands are available:
This section provides detailed descriptions of all the functionalities of the RV2 workflow. The following subsections are ordered according to sequence of the RV2 workflow.
Initialisation of RV2 is required at the beginning of all RV2 sessions. It does several necessary jobs:
Bring up a front-page providing useful links about RV2 and require users to accept RV2’s Terms and Agreements to proceed.
Initialize data structures and user session needed for RV2 to operate in Rhino environment.
Kick off compas_cloud
server in background and establish connection to it from Rhino.
If a previously saved .3dm file is being used, open the file directly without any Rhino windows open, instead of starting Rhino then opening the file.
Once RV2 has been initialised, previously saved .rv2 session file can be loaded to resume work.
There are many ways to generate a topological pattern. Each method has pros and cons, and the desired design or workflow will help determine which method is more appropriate.
In the case of the rib layout variations for the rib-stiffened funicular floor system, the boundary remains fixed (the footprint and depth of the floor). However, depending on the topology of the form diagram, the distribution and flow of forces change drastically.
In RV2, three types of Rhino geometries can be used to generate a Pattern :
Lines, Mesh and Surfaces. These pattern generation features would be particularly useful when there is already an existing structure with a geometry that one would like to recreate the pattern for.
Photographs and diagrams of different rose windows with complex mullion geometries, showing from left to right an outside picture, the equilibrated and piped form diagram, and the reciprocal force diagram: (a) Notre Dame de Mantes, France; (b) Notre Dame de Chartres, France (Photo by Holly Hayes); (c) Durham Cathedral, England (Photo by Carcharoth on Wikipedia); (d) Notre Dame de Paris, France (Photo by Ellen Brown); (e) Bisshop’s Eye of Lincoln Cathedral, England (Photo from Cornell University Library); (f) Sainte-Chapelle Paris, France.
Pattern
is a COMPAS mesh object. A mesh datastructure is network of faces, where the connectivities of the faces are defined by halfedge adjacencies.
RV2pattern_from_surfaces
is a new developed feature based on previous command RV2pattern_from_rhino_objects
.
A single 2D or 3D non-trimmed Rhino NURBS surface or multiple joined, non-trimmed surfaces can be used to generate a Pattern.
To generate a pattern simply select the icon “create pattern” --> “From Surfaces”, then select a single Surface or Polysurface and press Enter.
Quad-surfaces are subdivided based on UV mapping of the surface, given a default subdivision value for UV. You can differentiate the subdivision value in U and/or V direction by selecting an edge.
Non-quad surfaces are subdivided equally throughout the surface based on a subdivision value “n” and Catmull Clark subdivision. The n value must be an integer that is power of 2.
Modify Subdivision :
Once the default pattern is generated you can select "Subdivide Entire Mesh" to further subdivide the entire mesh by giving a new subdivision value. The subdivision value can be any integer for quad surfaces, and an integer that is power of 2 for non-quad surfaces.
To subdivide a single edge strip, select "Subdivide Edge Strip", then select a mesh-edge that belongs to the strip, and give a subdivision value following the same restrictions for quad and non-quad surfaces.
Continue modifying the pattern until you are satisfied. Select "Finish Subdivision" or press Enter to finish.
You can follow the steps of the following video and experiment with Subdivision Modification
until you are satisfied with the Pattern
.
A Rhino mesh object can be used to create a Pattern
. Since a Pattern is also a mesh object, the vertices and edges can be directly used to create the vertices and edges of the Pattern
.
One of the simplest, and the most manual, way to make the Pattern is to draw the edges of the Pattern
as Rhino lines. Each edge of the Pattern should be an individual line; all lines should be broken at all line intersections. In other words, these lines may not be overlapping.
The input set of lines must consist of closed loops of lines representing the faces of the Pattern.
If there are closed loops of lines, a Pattern
will be generated and all lines that do not form a closed loop, such as the "leaf" edges will be omitted.
Follow the instructions in the command window, choose outer boundary, inner boundaries and constraint curves. For the last step enter a target triangle edge length. Triangulated force pattern will be generated.
outer boundary is a closed polycurve that represents the outline of the diagram.
inner boundaries are openings of the intended design pattern.
constraint curves are where the vertices and edges will be forced to snapped onto.
Triangulation is a method that is fast and robust for creating a Pattern from a set of complex boundary features. However, triangulated patterns have no clear direction or hierarchy of the edges, which make it difficult to interact with (for example, if you wanted to attract forces using the force diagram).
RV2pattern_from_skeleton
is a powerful new RV2 feature that provides easy and intuitive method for generating complex patterns for free form vaults with just a few clicks.
RV2pattern_from_skeleton
is a feature based on the compas_skeleton
package. Fore more detailed information on the package, please check out its online documentation.
Choose "Create Pattern" --> "From Skeleton" from the tool bar, select a group of lines from Rhino and press Enter.
Follow the instructions in the command window, for each step click on the corresponding vertex, move cursor to input skeleton node width, leaf width and end extension respectively.
After initialising the skeleton, there will be available editing methods showing up in the command window. try out these options, get your ideal pattern.
increase the subdivision level of skeleton and finish editing. by clicking on "Finish", a force pattern diagram will be automatically generated.
RV2pattern_from_features
is based on the compas_singular
package. For more information on the package, please check out its online documentation.
RV2pattern_from_features
is in early stages of development, and may not always result in suitable solutions. The contents of this feature are subject to change, and will be improved in future releases of RV2.
Using the RV2pattern_from_features
command is a powerful and an effective way to generate quad mesh patterns from complex or irregular boundary conditions and point features, such as the British Museum Great Courtyard Roof.
The first example takes into account only the input surface to produce a pattern align with the boundaries. This aspect is important in funicular form finding in the case of non-supported boundaries.
The second example also takes into account point features on the surface to include pole points in the pattern. The point features at the corner can integrate local concentration of thrust. The other point features can integrate point loads or nodal supports. All these aspects are important to design a suitable pattern for funicular form finding.
This feature allows you to modify the attributes of the vertices of a Pattern
.
constraints : Rhino object to which the vertex is referenced or constrained to (not yet implemented)
is_fixed : fixes the x, y, z coordinates of the vertex
x : x coordinate of the vertex
y : y coordinate of the vertex
z : z coordinate of the vertex
This feature allows you to modify the attributes of the edges of a Pattern
.
lmax : maximum length desired for the edge during relaxation/smoothing
lmin : minimum length for the edge during relaxation/smoothing
q : force density
This feature allows you to manually move selected vertices of a Pattern
.
This feature allows you to delete vertices of a Pattern
. By deleting interior vertices of a pattern, holes can be created.
Using the force density method, this feature relaxes the entire Pattern
.
Using area-based smoothing (every vertex is repositioned to the centroid of its neighboring vertices), the pattern is smoothed.
Once the FormDiagram
has been successfully created, the ForceDiagram
can be created. When it is first created, the ForceDiagram
is the dual diagram of the FormDiagram
.
A ForceDiagram
is represented by the mesh datastructure.
The Force Diagram is the dual of the Form Diagram, in the sense that both diagrams have the same number of edges and that vertices in one diagram correspond to faces in the other, and vice versa.
Initially, the Force Diagram is created as the "centroidal dual" of the Form Diagram. This means that the geometry of the Force Diagram is defined by placing its vertices at the centroids of their corresponding faces in the Form Diagram.
In order for the Form and Force Diagram to describe the distribution of horizontal thrust in a three-dimensional network of compression forces in equilibrium with vertical loads applied to its nodes, they need to be not only dual, but also reciprocal.
Two diagrams are reciprocal if they are dual, and if their corresponding edges are at a constant angle with each other. Typically, corresponding edges are required to be parallel, or perpendicular, but any other constant angle is sufficient as well.
In RV2, the Form and Force Diagram are considered reciprocal if corresponding edges are perpendicular.
Once the Form and Force Diagram are reciprocal they describe the horizontal equilibrium of the corresponding three-dimensional force network. The edges of the Form Diagram define the directions and points of application of the forces, whereas the edges of the Force Diagram define the distribution of force magnitudes along those directions.
The magnitudes of horizontal forces are equal to the lengths of the edges in the Force Diagram, multiplied with a scaling factor.
A Pattern
object is a mesh datastructure that describes the topology of the structure. Several additional layers of information regarding the boundary conditions need to be added in order to give the Pattern
a structural meaning: identification of the supports; treatment of the openings and open edges; and defining the loading condition.
In RV2, a support is defined as a vertex of the structure that is fixed, and can have external horizontal reactions. By definition then, only the vertices on the boundary of a Pattern
can be defined as supports.
The vertices can be selected using these modes:
AllBoundaryVertices : all boundary vertices
Corners : all corner vertices
ByContinuousEdges : all vertices on the selected boundary edge (corner to corner)
Manual : manual selection by the user
An opening is a chain of edges at the boundary of a Pattern
, in between two support vertices. In general, openings in TNA cannot be straight, unless there are no internal forces in the non-boundary edges at the openings (i.e. barrel vault or cross vault).
Although this feature is optional, the user should be aware that the treatment of the openings are very much dependent on the type of vault that is being investigated. In some applications where openings may already have some curvature, the relaxation will make the Pattern
more "equilibrated" and optimal for the horizontal equilibrium solver later on.
This feature is currently under construction.
In TNA, externally applied loads can only be vertical. The user can define how the self-weight of the structure is calculated:
ByFace : the self-weight at each vertex is calculated by the tributary area of all the faces at the vertex (i.e. continuous shell), times the density and thickness, which are defined in the global settings
ByEdge : the self-weight at each vertex is calculated by the tributary lengths of all the edges at the vertex (i.e. grid shell), times the density and thickness, which are defined in the global settings
PointLoad : vertical point loads of can be applied to any vertices
This feature relaxes the Pattern
using the force density method, resulting in curved openings. For each opening, the amount of curvature is defined by using the sag , which is calculated based on the percentage of the length of the opening. The s for the boundary edges are automatically calculated based on the target sag values, which are then used for the force density method.
FormDiagram
is the 2D projection of the thrust network. In RV2, a FormDiagram
is represented by the mesh datastructure.
The boundary condition information, such as the support locations and loading conditions, is automatically inherited from the Pattern
. Any edges of the pattern, of which both endpoints are supports are removed from the FormDiagram
.
A FormDiagram
is represented by the mesh datastructure.
Depending on how the support vertices are defined, corners of the Pattern are automatically processed during the creation of the FormDiagram
.
A ThrustDiagram
is represented by the mesh datastructure.
In RV2, the ThrustDiagram
representing the thrust network, is an instance of the FormDiagram
, with the only difference being the coordinates. A ThrustDiagram
is simply an alternate visualisation of the FormDiagram
with updated coordinates. When a FormDiagram
is successfully created, the ThrustDiagram
is automatically created.
This example shows how to attract forces in the ThrustDiagram
, by moving the vertices of the ForceDiagram
, thereby increasing the magnitude of forces in the members of the ThrustDiagram
corresponding to the newly elongated edges.
Create pattern → FromSurfaces
Define boundary conditions → IdentifySupports → Select → ByContinuousEdges
Modify force diagram → MoveVertices
Horizontal equilibrium, Vertical equilibrium
Further modifications
In RV2, horizontal equilibrium is computed by parallelising the edges of the Form and Force Diagram to corresponding target vectors. These target vectors are defined as the weighted average of the vectors of corresponding edge pairs. Therefore, the most important parameter for the calculation of horizontal equilibrium in RV2 is alpha
, which is the weighting factor for the calculation of the target vectors.
If alpha = 100
, the target vectors are completely defined by the vectors of the edges of the Form Diagram. This means that only the geometry of the Force Diagram will be updated to achieve horizontal equilibrium. This is the default.
If alpha = 0
, the target vectors are completely defined by the edges of the force diagram. Therefore only the Form Diagram will be updated.
For all other values, the target vectors are calculated using the following formula:
Note that using alpha
efficiently requires a bit of practice and experience. Since the Form Diagram defines the intended layout of horizontal forces and RV2 has many tools for designing force layouts that provide a good starting point for form finding explorations, it is usually a good idea to start with alpha = 100
. However, once you have the horizontal equilibrium under control, playing around with lower alpha
values can have a significant influence on finding nicely balanced force distributions.
Computing horizontal equilibrium is an iterative process. The default number of iterations is 100
. For sensible force layouts, this value should go a long way. However, there are many cases in which more iterations are required. For example, if the Form Diagram has multiple open/unsupported edges, and especially if those edges have a low "sag" value, more iterations will typically be required to reduce all angle deviations between corresponding edges to less than 5 degrees.
Computing horizontal equilibrium is quite fast. Therefore, don't hesitate to set the number of iterations to 1000
or more if the need arises. However, don't go completely overboard either (10000
iterations is quite excessive in most cases), because the calculation has no stoppage criterion, since it tends to be more computationally expensive to check for convergence than to just run all the requested iterations.
Furthermore, resolving all angle deviations is not an absolute requirement, and is in many cases unnecessary. For example, the angle deviations between very short edges tend to be quite persistent as they are dominated by edges with (much) longer lengths during the calculation process. Since short edges in the Force Diagram also represent (relatively) small horizontal forces, these deviations can often be ignored.
The iterations of the horizontal equilibrium calculation process is dynamically visualised. The rate at which the diagrams are updated is controlled by the refreshrate. The default value is 10
, which means that the diagrams are updated every 10 iterations.
For large diagrams the dynamic visualisation slows down the calculations a little bit. In these cases, and/or for high numbers of iterations (> 1000
), it is therefore advisable to set the refreshrate to a higher value. For example, if the number of iterations is 1000
, then a refresh rate of 100
seems more appropriate.
Once the Form and Force Diagrams have been created and horizontal equilibrium has been established through parallelisation, the distribution of horizontal forces in the system is fixed. The actual magnitude of the horizontal forces depends on a scale factor and will determine the depth of the final thrust diagram. A higher scale factor results in higher horizontal forces and therefore a shallower three-dimensional shape. Vice versa, a lower scale factor results in lower horizontal thrust and thus a deeper solution.
The meaning of the scale factor and the magnitude of horizontal forces is related to the magnitude of the loads, which in turn are related to the self-weight of the resulting three-dimensional geometry.
Rather than asking you to "guess" the scale factor to get the three-dimensional shape you want, RV2 will determine the scale for you based on the desired height of the final solution.
The default value for the target height is 25% of the length of the diagonal of the bounding box of the Form Diagram (essentially of the bounding box of the footprint of your shell). This value tends to produce well-proportioned geometries.
The minimum value for the target height is 10% of the length of the diagonal. Currently this is hard-coded and can't be changed through the UI.
Create pattern → FromSkeleton
Define boundary conditions → IdentifySupports → Select → ByContinuousEdges
Modify force diagram → EdgeAttributes → Set lmin
and lmax
Modify form diagram → VertexAttributes → AllBoundaryVertices → Set is_fixed
to True
Modify form diagram → Relax
Once horizontal and vertical equilibriums have been successfully found, the user can interact with the three diagrams to continue design explorations.
'constraints': None
'is_anchor': False
'is_fixed': False
'px': 0.0
'py': 0.0
'pz': 0.0
't': 1.0 (thickness)
This feature allows the user to move any of the anchored vertices of the ThrustDiagram
in the z axis.
Under “Settings,” various global parameters and visualisation options can be modified. For each of the categories, various parameters and display settings can be modified. In general, various elements of the three diagrams turned on or off, and the colors of the elements can be customised. The modifiable parameters for each category are summarised below.
angles (float (5.0)) - Angle deviation tolerance for horizontal equilibrium. Default is 5 degrees.
angles (bool (True)) - Display angle deviations as dots on the edges of the FormDiagram
and the ForceDiagram
. Display of angle deviations are turned on by default.
horizontal.alpha (int (100)) - Default is 100 (or 'form100', meaning that the FormDiagram
remains fixed and only the ForceDiagram
will change during the Horizontal Equilibrium.
horizontal.kmax (int (100)) - Number of iterations for the Horizontal Equilibrium solver. Default is 100.
horizontal.refreshrate (int (10)) - Number of iterations to skip for the Conduit (dynamic drawing showing the iterations) during the Horizontal Equilibrium solver. Default is 10.
vertical.kmax (int (300)) - Number of iterations for the Vertical Equilibrium solver. Default is 300.
vertical.zmax (float (4.0)) - Default target height for the Vertical Equilibrium solver.
density.U (int (10)) - Number of divisions in the U direction of a surface for Create Pattern
> From Surface
. Default is 10.
density.V (int (10)) .- Number of divisions in the U direction of a surface for Create Pattern
> From Surface
. Default is 10.
pipes (float (0.01)) - Global display scale factor for pipes.
reactions (float (0.1)) - Global display scale factor for reaction forces at anchored vertices of the ThrustDiagram
.
residuals (float (1.0)) - Global display scale factor for residual forces at the non-anchored vertices of the ThrustDiagram
.
pipes (float (0.001)) - Tolerance threshold for displaying pipes
reactions (float (0.001)) - Tolerance for displaying reaction forces; if the reaction force is smaller than this value, it will not be displayed.
residuals (float (0.001)) - Tolerance for displaying residual forces; of the residual force is smaller than this value, it will not be displayed.
forces (bool (False)) - Display the edges of the ForceDiagram
in a based on its length, and the corresponding edges in the FormDiagram
are also displayed in the same color; red means longer edges (higher force magnitudes), blue means shorter edges (lower force magnitudes).
RV2 is based on the COMPAS framework, which means that RV2 can be integrated with various other COMPAS packages and extensions, such as best-fit TNA, load path optimization, and fabrication-related applications.
These extensions and integrations are currently under construction.
This example will show how to generate the roof of the British Museum Great Courtyard in London. This example will show how to:
Create a Pattern
from features (quad mesh)
Make creases in the ThrustDiagram
by modifying the ForceDiagram
Compare the influence of patterns on force flow and distribution for the same boundary conditions
For this example, we will generate patterns From Features
. In this Rhino file, there are four planar surfaces. Patterns B, C and D also have points on them.
Under Create Pattern
, select From Features
, then select one of the input surfaces. For Patterns B, C and D, also select the points as point features. For this example, we will use target edge length of 2.
The images shown in this example are showing all four Pattern options for comparison purposes only. In one RV2 session, only one pattern can be generated at a time.
The diagrams
Once the initial quad mesh has been generated, the pattern can be relaxed. Relaxation of the Pattern is not a requirement for successfully finding horizontal and vertical equilibrium. However, relaxing the Pattern during early stages of the RV2 workflow will ensure that the pattern is smooth, which will also make the eventual ThrustDiagram has smooth force distribution.
Once the Patterns have been defined relaxed, supports can be identified under Define Boundary Conditions
. In this example, we will use the fixed vertices of the Pattern as the supports. When Identify Supports
is selected, the fixed vertices of the Pattern will automatically be identified and defined as supports.
We will use all of the boundary vertices as supports, but not the singularities (the point features on the surface that were fixed in the previous step).
Create pattern → FromTriangulation
Define boundary conditions → IdentifySupports → Select → AllBoundaryVertices → Unselect → Manual
Modify thrust diagram → VertexAttributes → Manual → Set is_anchor
to True
Modify thrust diagram → MoveSupports
Create pattern → FromFeatures
Define boundary conditions → IdentifySupports → Select → Manual (few on the inside openings)
Modify force diagram → FlipEdges
Modify form diagram → VertexAttributes → AllBoundaryVerticees → Set is_fixed
to True
This example will show how to generate the ThrustDiagram for the Free-form Tile Vault built by the BRG in Zurich, 2010. This example will show how to:
Create a Pattern
from Rhino mesh object
Relax Pattern
using custom force density values (control the curvature of the unsupported boundaries)
Refine crease in the ThrustDiagram
by modifying the ForceDiagram
(to make/accentuate creases)
For this example, a pre-made Rhino mesh will be used to generate the Pattern
. Unzip and open the file below, and do: Create pattern
> From Mesh
.
Before the Pattern
can be relaxed with custom force density values (q), fixed vertices first need to be identified. By using the Corner
and ByContinuousEdges
selection options in Modify Pattern
> Vertices Attributes
, set is_fixed
attributes of the vertices to True
.
Once the fixed vertices have been identified, force densities can be assigned to the edges and the Pattern
can be relaxed. By using the Continuous
selection option in Modify Pattern
> Edges Attributes
, force density values can be defined for continuous chain of unsupported boundary edges. With new force density values assigned, the Pattern
can be relaxed using Modify Pattern
> Relax
. Setting qs and Relax
can be repeated iteratively to achieve the desired curvature of each of the unsupported boundaries. For this example, these q values are used.
Once the Pattern
has been relaxed, anchor vertices can be be defined. In this example, a few more vertices are manually added by using the Manual
selection option in Define Boundary Conditions
> IdentifySupports
. The vertices that are already fixed are automatically defined as anchors.
After a few hundred iterations, horizontal equilibrium is found.
Use TargetHeight
parameter in Vertical Equilibrium to achieve the desired height of the ThrustDiagram
. In this example, TargetHeight
of 4.5 is used.
The creases of this ThrustDiagram
, the edges indicated in the image below that span from anchor to anchor, can be refined by modifying the ForceDiagram
.
By moving the vertices of the ForceDiagram
to elongated the edges corresponding to the creases, the transition at the creases can be smoothened and refined.
This example will show how to generate a simplified version of the ThrustDiagram
of the Armadillo Vault. This example will show how to:
Create a (quad mesh) Pattern
from features
Relax Pattern
Create and move new anchor vertices ("drop downs") in the ThrustDiagram
From Features
uses trimmed or untrimmed surface as input. Open the file below, and select the trimmed surface as input in Create Pattern
> From Features
.
The first optional parameter will ask for any additional points on the surface to be defined as point features or singularities. This parameter will be skipped in this example. Press Enter to skip.
The second optional parameter is the desired target length for the Patten
. This value is the approximate target length for all edges of the Pattern
. For this example, the default target length of 1 is used. Press Enter to accept the default value of 1 and proceed.
The third and last optional feature will ask for the number of iterations for constrained Laplacian smoothing of the Pattern. The default number of iterations is 10. For this example, 30 iterations are used. Primary purpose of Laplacian smoothing in this step is to more evenly distribute the vertices along the boundaries.
Once the initial Pattern
has been generated, further modifications such as relaxation can be applied. In this example, the Pattern
will be relaxed with all of the boundary vertices fixed. Go to Modify Pattern
> Vertices Attributes
, then AllBoundaryVertices
. In the pop-up window, set the attribute 'is_fixed'
to True
. The fixed vertices now should be displayed in blue.
With all the boundary vertices fixed, go to Modify Pattern
then Relax
. The Pattern
should now be relaxed. Pattern
relaxation is based on the force density method (FDM), with force density of 1 set to all of the edges. The primary purpose of Pattern
relaxation is to reorient the edges of the Pattern
based on force information, rather than geometric information (such as Laplacian or centroidal smoothing where the repositioning of the vertices are based on the coordinates of neighboring vertices). By relaxing the Pattern
based on forces, the Pattern
will already be in a good, equilibrated starting geometry which will be helpful during later stages of form finding.
After relaxation, unfix all the vertices of the pattern by following the instructions in the previous step Unfixing of the vertices can be done (or not even necessary, if they are intended to be used as anchors) during any point before the creation of the FormDiagram
. However, for clarity of the procedures of the main workflow steps, all vertices are explicitly unfixed in this step.
Left - Pattern from feature with target length 1, without smoothing or relaxation
Middle - Pattern from feature with target length 1, and 30 iterations of constrained Laplacian smoothing (notice the more evenly distributed vertices along the boundaries)
Right - Pattern From Feature with target length 1, 30 iterations of constrained Laplacian smoothing and relaxation with all boundary vertices fixed (notice the much smoother continuous edges).
In order to define the supports of the vault, go to Define Boundary Conditions
> Identify Supports
> Select
. Choose ByContinuousEdges
, then select one of the edges on each of the three curving-out boundaries of the Pattern
as shown below. Once Enter is pressed, all the vertices along the continuous edges of the selected edges will be defined as supports, which are now shown in red.
Update Boundaries
provides a controlled and automated relaxation of each of the unsupported boundaries independently from one another using the force density method. In this example, the relaxation was intentionally done during the Modify Pattern
step with a specific attention to the boundaries and interior holes. So Update Boundaries
is skipped in this example.
Once the FormDiagram
and ForceDiagram
have been successfully created, Horizontal Equilibrium
can be run.
Even after several hundred iterations, the angle deviations may still be high and decrease slowly, which are typically due to very short edges in the ForceDiagram
. One way to help the algorithm, is to increase the minimum length constraint on all of the edges of the ForceDiagram
. Go to Modify Force Diagram
> EdgesAttributes
> All
, then set the attribute lmin
to 0.3. Run Horizontal Equilibrium
again, and there should be an immediate improvement.
If the angle deviations are still high, another way to help the two diagram reach horizontal equilibrium is to relax the FormDiagram
. Unlike the Pattern
relaxation (where every edge was assigned force density of 1), every edge of the FormDiagram now has different force densities, since the magnitude of the forces (or the edges of the ForceDiagram
) are not the same. Relaxing the FormDiagram
after few hundred iterations of Horizontal Equilibrium
will use the current force densities. Go to Modify Form Diagram
> Relax
, then there should be a very slight change and smoothing of the FormDiagram.
After relaxing the FormDiagram
, horizontal equilibrium should be found within a couple of hundred iterations.
Once horizontal equilibrium has been found, run Vertical Equilibrium with a target height of 7.5 to obtain the result below.
In order to convert some of the vertices on the interior holes to new anchors, go to Modify Thrust Diagram
> Vertices Attributes
, then select the vertices shown below and set the attribute is_anchor
to True
.
By using Move Supports
in Modify Thrust Diagram
, supports of the ThrustDiagram
can be moved along the z axis. One by one, select the new anchors and move it to the level of the form diagram (z=0).
Once the new anchors have been moved down, run Vertical Equilibrium
again with target height of 7.5, and you should see a new ThrustDiagram
that resembles the Armadillo Vault.
In this example, we will use the FormDiagram
and ThrustDiagram
resulting from a pattern designed From Freatures
and inspired by the geometry and boundary conditions of the British Museum. We will generate a tessellation based on the dual of a remeshed triangulation of the ThrustDiagram
.
We will do this in small incremental steps using JSON files to store various updated versions of the Form Diagram mesh and communicate between parts of the procedure.
To triangulate the Form Diagram mesh we can simply convert all quads to triangles. Note that the quality of the resulting mesh is not considered in this step. This is okay because we will still improve mesh quality through remeshing.
We will remesh in VS Code using the COMPAS viewer for visualisation, and again export the result to JSON to continue working with the remeshed triangulation in Rhino. The result is available for download at the bottom of this page.
Note that you could also do this directly from Rhino using the RPC cloud. However, the current procedure illustrates an alternative workflow using CPython directly in an editor outside of Rhino.
The examples shown in this section were created using RV2 . They will be updated soon, and be compatible with the latest release of RV2.
The examples shown in this section were created using RV2 . They will be updated soon, and be compatible with the latest release of RV2.
For the remeshing we will use compas_cgal
. The underlying remeshing function in CGAL is documented .
The examples shown in this section were created using RV2 v1.0.0. They will be updated soon, and be compatible with the latest release of RV2.
The examples shown in this section were created using RV2 v1.0.0. They will be updated soon, and be compatible with the latest release of RV2.
Undo (Ctrl + z) and Redo (Ctrl + y) functionality
Bug fixes with skeleton objects
Minor bug fixes and enhancements
Integration of various force layout mechanisms through pattern design and modification.
Form, Force, and Thrust Diagrams re-implemented as half-edge data structures for more flexible and robust topological operations.
Automatic updating of unsupported boundaries.
Weighted horizontal equilibrium calculations (in pure Python).
Dynamic visualisation of horizontal equilibrium calculations.
Force scaling based on target heights.
Iterative vertical equilibrium calculations with automatic self-weight updating.
Form/Force Diagram geometry constraints.
Horizontal force constraints.
Make internal openings.
Internal supports ("Drop-downs").
RV2 session files for saving and loading design sessions.
Create Pattern
From Rhino objects (lines, mesh, surface)
From Skeleton
From Triangulation (triangulated mesh from boundary features)
From Features (quad mesh from trimmed surface and point features)
Modify Pattern
Relax pattern using force density
Smooth pattern using per-vertex centroidal smoothing
Define Boundary Conditions
Automatic relaxation of unsupported boundaries
Horizontal Equilibrium
Alpha - weight factor for parallelisation
Vertical Equilibrium
TargetHeight - parameter for computing the ThrustDiagram based on a desired target height
Scale - parameter for computing the ThrustDiagram based on a desired scale of force densities
Modify diagrams
FormDiagram
Diagram Attributes
Vertices Attributes
Edges Attributes
Move Vertices
Relax (using current force densities)
Smooth(centroidal)
ForceDiagram
Diagram Attributes
Vertices Attributes
Edges Attributes
Move Vertices
ThrustDiagram
Diagram Attributes
Vertices Attributes
Move Supports
Undo and Redo functions
Pattern from polysurfaces
Synchronized topological operations on Form and Force Diagrams.
Integration of tension members.
Assignment of additional/live loads.
Lumped stress visualisation.
Interactive inspection of the topological relation between the diagrams.
...
Future releases will focus on the integration of recent research at the BRG related to funicular form finding. This includes the following.
Automated force distribution finding based on target surfaces ("Best-fit").
Automated pattern modifications for live load cases.
Assignment of force distribution templates.
...
The block geometries generated using the intrados and extrados, which are offsets of the initial mesh, contain two main hexagonal faces that are not planar. If the blocks are to be milled using stone blanks, milling both sides of the stone would be not only time intensive, but also result in loss of precision during the flipping of the blocks.
One way to address this problem, would be to make one of the two hexagonal faces planar so that the block is only milled on one side and does not need to be flipped. This technique was used for the Armadillo Vault, where the inner face of the blocks had double curvature, while the top face remained flat.
of RV2, released on September 14
First stable release of RV2, released on July 15th for the .
The examples shown in this section were created using RV2 . They will be updated soon, and be compatible with the latest release of RV2.
Please refer to the GitHub repository to stay informed about the latest developments of RV2. If you use RV2 for projects, publications or other applications, please cite RV2:
RhinoVAULT 2 (RV2) is a software package for structural form finding using the Thrust Network Approach (TNA) to intuitively create and explore compression-only structures. RV2 was developed by the Block Research Group.
The “Software” shall be considered the compiled RV2 plugin to the Rhinoceros® software of Robert McNeel and Associates, Seattle, and the corresponding documentation to RV2. For the avoidance of doubt, Rhinoceros® shall not be considered part of RV2 and/or the Software and it is the LICENSEE’s responsibility to obtain the necessary Rhinoceros® license. Source code shall not be considered part of the Software.
ETH Zurich hereby grants a single, non-exclusive, world-wide, royalty-free license to use Software subject to all the terms and conditions of this Agreement to the LICENSEE.
The Software may be used for commercial and/or non-commercial purposes. The LICENSEE retains all rights to results from such use. The LICENSEE and/or its employees may use the Software by himself/themselves, only.
Reproduction is prohibited except for the provisions of the applicable law (article 21 URG [Bundesgesetz über das Urheberrecht, SR 231.1]).
Neither modification, combination with other commercial applications or other preparation of derivative works of the Software, nor reverse engineering, decompilation, disassembly or other reduction of any portion of the Software is permitted except for the provisions of the applicable law (article 21 URG [Bundesgesetz über das Urheberrecht, SR 231.1]).
Assignment to a third party is prohibited.
Any report or publication of results obtained by the Software has to be acknowledged by citing the publication listed under article 1.
Ownership and intellectual property rights in and to the Software shall remain in ETH Zurich.
ETH Zurich reserves the right to withdraw distribution privileges from any group, individual, or organization for any reason.
ETH Zurich has no obligation of maintenance, support, upgrades or new releases and disclaims all costs associated with serving, repair or correction.
The Software is provided “as is”. ETH Zurich does not make any warranty of any kind. The LICENSEE assumes the entire risk as to the results and performance of the SOFTWARE. Disclaimed warranties include for example:
warranty of merchantability, satisfactory quality and fitness for a particular purpose
warranty of accuracy of results, of the quality and performance of the Software
warranty of noninfringement of the intellectual property rights of third parties.
The tool was developed to support the user in the form finding process of vaulted compression structures in the early design phase. It is obvious that prior to any realization of structures based on designs obtained with RV2, a detailed structural analysis is necessary.
ETH Zurich disclaims all liabilities. ETH Zurich shall not have any liability for any direct or indirect damage except for the provisions of the applicable law (article 100 OR [Schweizerisches Obligationenrecht]).
In the case of fundamental breach through the LICENSEE, this Agreement may be terminated by ETH Zurich at any time. On termination all copies of the Software have to be destroyed.
If any provisions of this Agreement will become invalid or unenforceable, such invalidity or enforceability shall not affect the other provisions of Agreement which shall remain in full force and effect provided that the basic intent of the parties is preserved. The parties will in good faith negotiate substitute provisions to replace invalid or unenforceable provisions which reflect the original intentions of the parties as closely as possible and maintain the economic balance between the parties.
This Agreement as well as any and all matters arising out of it shall exclusively be governed by and interpreted in accordance with the laws of Switzerland, excluding its principles of conflict of laws.
If any dispute, controversy or difference arises between the Parties hereto in connection with or out of this Agreement, the parties hereto shall first attempt to settle it amicably. Should settlement not be achieved, the Courts of Zurich-City shall have exclusive jurisdiction.
By using RV2, you indicate your acceptance of these legal terms.
An open source Python-based framework for computational research in Architecture, Engineering and Digital Fabrication.
The fundamental principle behind COMPAS is to provide to the research community a computational core that is independent of a specific CAD ecosystem and can be used in various environments across platforms.
Research and development based on COMPAS can therefore take better advantage of the available state of the art libraries for, for example geometry processing or robotic control, while maintaining compatibility with various software tools of the AEC industry. As a result, researchers can develop their work more freely and interact more easily with researchers from other fields, and with partners from industry.
The goal is to facilitate collaboration across disciplines and break the endless cycle of reinvention of methods and algorithms due to the lack of transparency and reproducibility of research in our field.
The main library of COMPAS provides flexible data structures, a geometry processing library, robot fundamentals, numerical solvers, and various other components as a base framework for computational research.
CAD tools are everywhere in Architecture, Engineering, Fabrication, and Construction (AEFC), both in research and in practice. COMPAS provides a consistent interface for visualising and interacting with data structures, and for working with geometry, in Blender, Rhino, RhinoMac, and Grasshopper.
To simplify the exchange between CAD systems, COMPAS supports several 3D geometry file formats for loading and saving 3D geometry. Currently, the following formats are supported: OBJ, OFF, PLY, STL, GLTF, URDF.
Using flexible data management with Python dictionaries and json serialisation, instances of COMPAS data structures and geometry objects can be saved to disk, sent over a network or to a subprocess, and reloaded without loss of information.
In addition to the core library, COMPAS provides an ever-growing collection of plugins, extensions, and tools.
Plugins are packages developed and maintained by the core development team (compas-dev
) that provide missing functionality or faster alternatives to (pure Python) COMPAS core algorithms, often by wrapping state of the art, external libraries. Examples of plugins are compas_triangle, compas_libigl, and compas_cgal.
Extensions are packages built on top of the core library, and potentially some of its plugins, to provide entirely new functionality to the framework related to specific fields in the AEFC industry. Examples are COMPAS FAB and COMPAS FEA.
Tools focus on providing user interfaces for all of the above. RhinoVAULT 2 is the first example of a UI-based tool built entirely with packages and functionality from the COMPAS ecosystem.
At the moment, it is not possible to create a custom UI or menu in Rhino for Mac. However, the RV2 commands are still accessible and executable through the command line.
RV2 is developed based on the theory of Thrust Network Analysis (TNA). Please check out the Thrust Network Analysis page, as well as the research section of the Block Research Group home page to find out more about TNA and many other related areas of ongoing research.
For any issues involving installation, errors or bugs, please file an issue on the RV2 Issue Tracker, and we will reach out to you as soon as possible.
We very much welcome your feedback! Please use the RV2 Issue Tracker to submit comments, feedback and feature requests.
Yes! You can contribute to the RV2 repository (an other packages in the COMPAS ecosystem) by following the COMPAS Developer Guide.
The first step of the workflow is to generate the topology of the FormDiagram
, which is called the Pattern
in RV2. A Pattern
is a collection of vertices interconnected by lines, represented by the COMPAS mesh datastructure.
RV2 offers several methods for generating a Pattern
. Each method has a direct influence not only on the topology of the eventual shell structure, but also the type of application and interaction that is desired during the design process.
RV2 bundles the following COMPAS packages:
This means that the COMPAS packages listed above (with the exception of compas_triangle
) are also available in the Rhino PythonScript Editor. To verify this, simply open the editor and run the following snippet:
Note that Rhino uses IronPython 2.7.8
. Therefore print statements are still in the "old" Python 2x format...
In this final tutorial, we will use these packages to extend the functionality of RV2 with custom Python scripts. For communication between these scripts and RV2, we will use the *.rv2
session files.
To load a Form Diagram from a RV2 session file and visualise it in a script, you could do the following:
Save the script in the same directoy as the session file ('bm-3.rv2'
), or provide the full path to the session file. Otherwise Rhino will not be able to find it.
To extract information from the Form Diagram you can simply use the typical COMPAS mechanisms for extracting data out of meshes.
Using the data and attribute "accessors", we can for example extract the values of the reaction forces at the supports, or the axial forces in the edges.
With this we can, for example, compute a rough approximation of the (lumped) stress at the nodes.
When you install RV2 using the , these packages are installed in a environment and registered in Rhino. It is the same as the "normal" installation process of COMPAS packages, but automated. Also the command plugin is installed with an automated version of the typical installation process for COMPAS-based Rhino command plugins.
The examples shown in this section were created using RV2 v1.0.0. They will be updated soon, and be compatible with the latest release of RV2.
To avoid having to process the session file over and over again to extract the information about the form diagram, we export the Form Diagram data to a separate JSON file (form.json
) that can then be used as input instead. We also draw the form diagram as a simple mesh in Rhino.
After exporting the data we can create the form diagram as follows.