In this section, we introduce the essential Nodes available in the Dynamo Library that will help you create your own visual program like a pro.

• Geometry for Computational Design: How do I work with geometric elements in Dynamo? Explore multiple ways to create simple or complex geometries from primitives.

• The Building Blocks of Programs: What is "Data" and what are some fundamental types I can start using in my programs? Also, learn more about incorporating math and logic operations in your design workflow.

• Designing with Lists: How do I manage and coordinate my data structures? Understand more about the concept of List and use it to manage your design data efficiently.

• Dictionaries in Dynamo: What are Dictionaries? Find out how to use dictionaries to look up specific data and values from existing results.

Dynamo as Extension vs Dynamo Sandbox

Dynamo is an active open-source development project. Find out the list of software that supports Dynamo.

Launch Dynamo as Extension

Dynamo comes pre-installed with software such as Revit3D, FormIt, Civil3D and etc.

For more guidance on using Dynamo with a specific software, we recommend referring to the following sections:

• Dynamo for Revit

• Dynamo for Civil 3D

If you would like to use Dynamo as a standalone application. Continue reading for guidance on downloading the Sandbox.

Get Dynamo Sandbox

Download

The Dynamo application is available from the Dynamo website. Both official, past or pre-released versions are available from the download page. Visit Get Dynamo page and Click Download for the official released version.

If you are looking for previous or 'bleeding edge' development releases, all versions can be found in the lower section from the same page.

Unzip

Before launching any version you have downloaded, you are required to unzip the content to your chosen folder.

Download and install 7zip to your computer for this step.

Right-click on the zip file and select Extract All...

Choose a destination to unzip all the files.

Launching

In your destination folder, double-click on DynamoSandbox.exe to launch it

You will see the DynamoSandbox startup screen as follow.

Congratulations, you have now finished the setup for using DynamoSandbox!

User Interface Overview

The User Interface (UI) for Dynamo is organized into five main regions. We will briefly cover the overview here and further explain the Workspace and Library in the following sections.

1. Menus

2. Toolbar

3. Library

4. Workspace

5. Execution bar

Menus

Here are Menus for basic functionality of the Dynamo application. Like most Windows software, the first two menus related to managing files, operations for selection and content editing. The remaining menus are more specific to Dynamo.

Dynamo Menus

General info and settings can be found on the Dynamo drop down menu.

1. About - Find out the Dynamo version installed on your machine.

2. Agreement to Collect Usability Data - This allows you to opt-in or out for sharing your user data to improve Dynamo.

3. Preferences - Includes settings such as define the application's decimal point precision and geometry render quality.

4. Exit Dynamo

Help

If you're stuck, check out the Help Menu. You may access one of the Dynamo reference websites through your internet browser.

1. Getting Started - A brief introduction to using Dynamo.

2. Interactive Guides -

3. Samples - Reference example files.

4. Dynamo Dictionary - Resource with documentation on all nodes.

5. Dynamo Website - View the Dynamo Project on GitHub.

6. Dynamo Project Wiki - Visit the wiki for learning about development using the Dynamo API, supporting libraries and tools.

7. Display Start Page - Return to the Dynamo start page when within a document.

8. Report A Bug - Open an Issue on GitHub.

Toolbar

Dynamo's Toolbar contains a series of buttons for quick access to working with files as well as Undo [Ctrl + Z] and Redo [Ctrl + Y] commands. On the far right is another button that will export a snapshot of the workspace, which is extremely useful for documentation and sharing.

Library

The Dynamo Library is a collection of functional libraries, each Library containing Nodes grouped by Category. It consists basic libraries which are added during default installation of Dynamo, as we continue to introduce its usage, we will demonstrate how to extend the base functionality with Custom Nodes and additional Packages. The Library section will cover a more detailed guidance on using it.

Workspace

The Workspace is where we compose our visual programs, you may also change its Preview setting to view the 3D geometries from here. Refer Workspace for more details.

Execution Bar

Run your Dynamo script from here. Click the dropdown icon on the Execution button to change between the different modes.

• Automatic: Runs your script automatically. Changes are updated in realtime.

• Manual: Script only runs when the 'Run' button is clicked. Useful for making changes to a complicated and 'heavy' script.

• Periodic: This option is grayed out by default. Only available when the DateTime.Now node is used. You can set the graph to run automatically at a specified interval.

This Primer includes chapters developed with Mode Lab. These chapters focus on the essentials you will need to get up and running developing your own visual programs with Dynamo and key insights on how to take Dynamo further.

Primer User Guide

This guide is designed to cater to readers from different backgrounds and skill levels. General introduction about Dynamo setup, user interface and key concepts can be found in the following sections, we recommend new users to cover the following topics:

• What is Dynamo & How Does It Work?

• Setup for Dynamo

• User Interface

• Nodes and Wires

For users who would like to develop a more in-depth understanding of each element such as a specific Nodes and the concept behind it, we cover the fundamentals in its own chapter.

• Essential Nodes & Concepts

If you would like to see the demonstration of Dynamo workflows, we have included some graphs in the Sample Workflows section. Follow the attached instructions to create your own Dynamo graphs.

• Parametric Vase

• Attractor points

The Community

Dynamo wouldn't be what it is without a strong group of avid users and active contributors. Engage the community by following the Blog, adding your work to the Gallery, or discussing Dynamo in the Forum.

The Platform

Dynamo is envisioned as a visual programming tool for designers, allowing us to make tools that make use of external libraries or any Autodesk product that has an API. With Dynamo Sandbox we can develop programs in a "Sandbox" style application - but the Dynamo ecosystem continues to grow.

The source code for the project is open-source, enabling us to extend its functionality to our hearts content. Check out the project on GitHub and browse the Works in Progress of users customizing Dynamo.

Browse, Fork, and start extending Dynamo for your needs

For Dynamo v2.13 and newer

Dynamo is an open source visual programming platform for designers.

Welcome

You have just opened the Dynamo Primer, a comprehensive guide to visual programming in Autodesk Dynamo. This primer is an on-going project to share the fundamentals of programming. Topics include working with computational geometry, best practices for rules-based design, cross-disciplinary programming applications, and more with the Dynamo Platform.

The power of Dynamo can be found in a wide variety of design-related activities. Dynamo enables an expanding list of readily accessible ways for you to get started:

• Explore visual programming for the first time

• Connect workflows in various software

• Engage an active community of users, contributors, and developers

• Develop an open-source platform for continued improvement

In the midst of this activity and exciting opportunity for working with Dynamo, we need a document of the same caliber, the Dynamo Primer.

Refer to the primer user guide to find out what you can expect to learn from this primer.

We are continuously improving Dynamo, so some features may look different from what is represented in this Primer. However, all functionality changes will be correctly represented.

Open Source

The Dynamo Primer project is open source! We're dedicated to providing quality content and appreciate any feedback you may have. If you would like to report an issue on anything at all, please post them on our GitHub issue page: https://github.com/DynamoDS/DynamoPrimer/issues

If you would like to contribute a new section, edits, or anything else to this project, check out the GitHub repo to get started: https://github.com/DynamoDS/DynamoPrimer.

The Dynamo Primer Project

The Dynamo Primer is an open-source project, initiated by Matt Jezyk and the Dynamo Development team at Autodesk.

Mode Lab was commissioned to write the First Edition of the Primer. We thank them for all of their efforts in establishing this valuable resource.

John Pierson of Parallax Team was commissioned to update the Primer to reflect the Dynamo 2.0. revisions.

Matterlab was commissioned to update the Primer to reflect the Dynamo 2.13. revisions.

Archilizer was commissioned to update the primer to reflect the Dynamo 2.17. revisions.

Wood Rodgers was commissioned to update the Primer with content for Dynamo for Civil 3D.

Acknowledgments

A special thanks to Ian Keough for initiating and guiding the Dynamo project.

Thank you to Matt Jezyk, Ian Keough, Zach Kron, Racel Amour and Colin McCrone for enthusiastic collaboration and the opportunity to participate on a wide array of Dynamo projects.

Software and Resources

Dynamo Please refer to the following sites for the most current stable release of Dynamo.

http://dynamobim.com/download/ or http://dynamobuilds.com

*Note: Starting with Revit 2020, Dynamo is bundled with Revit releases, resulting in manual installation not being required. More information is available at this blog post.

DynamoBIM The best source for additional information, learning content, and forums is the DynamoBIM website.

http://dynamobim.org

Dynamo GitHub Dynamo is an open-source development project on GitHub. To contribute, check out DynamoDS.

https://github.com/DynamoDS/Dynamo

Contact Let us know about any issues with this document.

Dynamo@autodesk.com

License

Copyright 2023 Autodesk

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

The Library contains all of the loaded Nodes, including the ten default categories Nodes that come with the installation as well as any additionally loaded Custom Nodes or Packages. The Nodes in the Library are organized hierarchically within libraries, categories, and, where appropriate, subcategories.

• Basic Nodes: Comes with default installation.

• Custom Nodes: Store your frequently used routines or special graph as Custom Nodes. You can also share your Custom Nodes with the community

• Nodes from the Package Manager: Collection of published Custom Nodes.

We will go through the hierarchy of Nodes categories, show how you can search quickly from the library and learn about some of the frequently used Nodes among them.

Library Hierarchy for Categories

Browsing through these categories is the fastest way to understand the hierarchy of what we can add to our Workspace and the best way to discover new Nodes you haven't used before.

Browse the Library by clicking through the menus to expand each category and its subcategory

1. Library

2. Category

3. Subcategory

4. Node

These further categorize the Nodes among same subcategory based on whether the Nodes Create data, execute an Action, or Query data.

Hover your mouse over a Node to reveal more detailed information beyond its name and icon. This offers us a quick way to understand what the Node does, what it will require for inputs, and what it will give as an output.

1. Description - plain language description of the Node

2. Icon - larger version of the icon in the Library Menu

3. Input(s) - name, data type, and data structure

4. Output(s) - data type and structure

Quick search in Library

If you know with relative specificity which Node you want to add to your Workspace, type in the Search field to look up all matching Nodes.

Choose by clicking on the Node you wish to add or hit Enter to add highlighted nodes to the center of the Workspace.

Search by hierarchy

Beyond using keywords to try to find Nodes, we can type the hierarchy separated with a period in the Search Field or with Code Blocks (which use the Dynamo textual language).

The hierarchy of each library is reflected in the Name of Nodes added to the Workspace.

Typing in different portions of the Node's place in the Library hierarchy in the library.category.nodeName format returns different results

• library.category.nodeName

• category.nodeName

• nodeName or keyword

Typically the Name of the Node in the Workspace will be rendered in the category.nodeName format, with some notable exceptions particularly in the Input and View Categories.

Beware of similarly named Nodes and note the category difference:

• Nodes from most libraries will include the category format

• Point.ByCoordinates and UV.ByCoordinates have the same Name but come from different categories

• Notable exceptions include Built-in Functions, Core.Input, Core.View, and Operators

Frequently Used Nodes

With hundreds of Nodes included in the basic installation of Dynamo, which ones are essential for developing our Visual Programs? Let's focus on those that let us define our program's parameters (Input), see the results of a Node's action (Watch), and define inputs or functionality by way of a shortcut (Code Block).

Input Nodes

Input Nodes are the primary means for the User of our Visual Program - be that yourself or someone else - to interface with the key parameters. Here are some available from the Core Library:

Watch & Watch3D

The Watch Nodes are essential to managing the data that is flowing through your Visual Program. You can view the result of a Node through the Node data preview by hovering your mouse over the node.

It will be useful to keep it revealed in a Watch Node

Or see the geometry results through a Watch3D Node.

Both of these are found in the View Category in the Core Library.

Code Block

Code Block Nodes can be used to define a block of code with lines separated by semi-colons. This can be as simple as X/Y.

We can also use Code Blocks as a shortcut to defining a Number Input or call to another Node's functionality. The syntax to do so follows the Naming Convention of the Dynamo textual language, DesignScript.

Here is a simple demonstration (with instructions) for using Code Block in your script.

1. Double-click to create a Code Block Node

2. Type Circle.ByCenterPointRadius(x,y);

3. Click on Workspace to clear the selection should add x and y inputs automatically.

4. Create a Point.ByCoordinates Node and a Number Slider then connect them to the inputs of the Code Block.

5. The result of the executing the Visual Program is shown as the circle in the 3D Preview

Main Workspace

The Dynamo Workspace consists of four main elements.

1. All Active Tabs.

2. Preview Mode

3. Zoom/Pan Controls

4. Node in Workspace

All Active Tabs

When you open a new file, a new Home Workspace will be opened by default.

You may create a Custom Node and open it in a Custom Node Workspace.

Preview Mode

There are 3 methods to switch between different previews:

a. Using the top right icons

b. Right-click in Workspace

• Switch from 3D Preview to Graph Preview

• Switch from Graph Preview to 3D Preview

c. Using keyboard shortcut (Ctrl+B)

Zoom/Pan Controls

You may use icons or a mouse to navigate in either workspace.

a. In Graph Preview Mode

• Using icons:
• Using mouse:

  • Left-click - Select

  • Left-click and drag - Selection box to select multiple nodes

  • Middle scroll up/down - Zoom in/out

  • Middle-click and drag - Pan

  • Right-click anywhere on canvas - Open In-Canvas Search

b. In 3D Preview Mode

• Using icons:
• Using mouse:

  • Middle scroll up/down - Zoom in/out

  • Middle-click and drag - Pan

  • Right-click and drag - Orbit

Node in Workspace

Left-click to select any Node.

To select multiple Nodes, Click and drag to create a selection box.

Nodes

In Dynamo, Nodes are the objects you connect to form a Visual Program. Each Node performs an operation - sometimes that may be as simple as storing a number or it may be a more complex action such as creating or querying geometry.

Anatomy of a Node

Most Nodes in Dynamo are composed of five parts. While there are exceptions, such as Input Nodes, the anatomy of each Node can be described as follows:

1. Name - The Name of the Node with a Category.Name naming convention

2. Main body - The main body of the Node - Right-clicking here presents options at the level of the whole Node

3. Ports (In and Out) - The receptors for Wires that supply the input data to the Node as well as the results of the Node's action

4. Default Value - Right-click on an input Port - some Nodes have default values that can be used or not used.

5. Lacing Icon - Indicates the Lacing option specified for matching list inputs (more on that later)

Nodes Input/Output Ports

The Inputs and Outputs for Nodes are called Ports and act as the receptors for Wires. Data comes into the Node through Ports on the left and flows out of the Node after it has executed its operation on the right.

Ports expect to receive data of a certain type. For instance, connecting a number such as 2.75 to the Ports on a Point By Coordinates Node will successfully result in creating a Point; however, if we supply "Red" to the same Port it will result in an error.

1. Port Label

2. Tool Tip

3. Data Type

4. Default Value

Node States

Dynamo gives an indication of the state of the execution of your Visual Program by rendering Nodes with different color schemes based on each Node's status. The hierarchy of states follows this sequence: Error > Warning > Info > Preview.

Hovering or right-clicking over the Name or Ports presents additional information and options.

1. Satisfied inputs - A node with blue vertical bars over its input ports is well-connected and has all of its inputs successfully connected.

2. Unsatisfied inputs – A node with a red vertical bar over one or more input ports needs to have those inputs connected.

3. Function – A node that outputs a function and has a gray vertical bar over an output port is a function node.

4. Selected - Currently selected nodes have an aqua highlight around their border.

5. Frozen - A translucent blue node is frozen, suspending the execution of the node.

7. Warning - A yellow status bar underneath the node indicates Warning state, meaning the node either lacks input data or may have incorrect data types.

8. Error - A red status bar underneath the node indicates that the node is in an Error state.

9. Info - Blue status bar underneath the node indicates Info state, which flags useful information about nodes. This state can be triggered when approaching a maximum value supported by the node, using a node in a way that has potential performance impacts, etc.

Handling Error or Warning Nodes

1. Warning Tooltip - "Null" or no data cannot be understood as a Double, i.e., a number

2. Use the Watch Node to examine the input data

3. Upstream the Number Node is storing "Red," not a number

Freezing Nodes

In some situations, you may want to prevent the execution of specific nodes in your Visual Program. You can do this by "freezing" the node, which is an option under the node's right-click menu.

Freezing a node also freezes the nodes that are downstream of it. In other words, all the nodes that depend on the output of a frozen node will also be frozen.

Wires

Wires connect between Nodes to create relationships and establish the Flow of our Visual Program. We can think of them literally as electrical wires that carry pulses of data from one object to the next.

Program Flow

Wires connect the output Port from one Node to the input Port of another Node. This directionality establishes the Flow of Data in the Visual Program.

Input Ports are on the left side and the Output Ports are located on the right side of Nodes, hence, we can generally say that the Program Flow moves from left to right.

Creating Wires

Create a Wire by left-click on a Port subsequently left-click on the port of another Node to create a connection. While we are in the process of making a connection, the Wire will appear dashed and will snap to become solid lines when successfully connected.

The data will always flow through this Wire from output to input; however, we may create the wire in either direction in terms of the sequence of clicking on the connected Ports.

Editing Wires

Frequently we will want to adjust the Program Flow in our Visual Program by editing the connections represented by the Wires. To edit a Wire, left click on the input Port of the Node that is already connected. You now have two options:

• Change connection to an input Port, left-click on another input Port

• To remove the Wire, pull the Wire away and left-click on Workspace

• Reconnect multiple wires using Shift+left-click

• Duplicate a wire using Ctrl+left-click

Default vs Highlighted Wires

By default, our Wires will be previewed with a gray stroke. When a Node is selected, it will render any connecting Wire with the same aqua highlight as the Node.

1. Highlighted Wire

2. Default Wire

Hide Wires by Default

In case you prefer to hide the Wires in your graph, you can find this option from View > Connectors > untick Show Connectors.

With this setting, only the selected Nodes and its joining Wires will be shown in faint aqua highlight.

Hide Individual Wire Only

You can also hide selected wire only by Right-clicking on the Nodes output > select Hide Wires

Dynamo is a visual programming application that can be downloaded and run in either stand-alone "Sandbox" mode or as a plug-in for other software like Revit, FormIt or Civil 3D.

The Process

Dynamo enables us to work within a Visual Programming process wherein we connect elements together to define the relationships and the sequences of actions that compose custom algorithms. We can use our algorithms for a wide array of applications, from processing data to generating geometry, all in real-time and without writing a lick of code.

Connecting Nodes and Wires

Nodes and Wires are the key components in Dynamo to support a visual programming process. It help establish strong visual and systemic relationships between the parts of a design. Using simple mouse-click to connect the Nodes easily while developing and optimizing your design workflow.

What can Dynamo Achieve?

From using Visual Programming for project workflows to developing customized tools, Dynamo is an integral aspect of a wide variety of exciting applications.

Follow the Dynamo in Action board on Pinterest.

As a Visual Programming environment, Dynamo enables you to craft the way that data is processed. Data is numbers or text, but so is Geometry. As understood by the Computer, Geometry - or sometimes called Computational Geometry - is the data we can use to create beautiful, intricate, or performance-driven models. To do so, we need to understand the ins and outs of the various types of Geometry we can use.

Curves in Dynamo

What is Curve?

Curves are the first Geometric Data Type we've covered that have a more familiar set of shape descriptive properties - How curvy or straight? How long or short? And remember that Points are still our building blocks for defining anything from a line to a spline and all the Curve types in between.

1. Line

2. Polyline

3. Arc

4. Circle

5. Ellipse

6. NURBS Curve

7. Polycurve

Line

NURBS Curve

NURBS is a model used for representing curves and surfaces accurately. A sine curve in Dynamo using two different methods to create NURBS Curves to compare the results.

1. NurbsCurve.ByControlPoints uses the List of Points as Control Points

2. NurbsCurve.ByPoints draws a Curve through the List of Points

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

Deep Dive into...

Curves

The term Curve is generally a catch-all for all different sort of curved (even if straight) shapes. Capital "C" Curve is the parent categorization for all of those shape types - Lines, Circles, Splines, etc. More technically, a Curve describes every possible Point that can be found by inputting "t" into a collection of functions, which may range from the simple (x = -1.26*t, y = t) to functions involving calculus. No matter what kind of Curve we are working with, this Parameter called "t" is a property we can evaluate. Furthermore, regardless of the look of the shape, all Curves also have a start point and end point, which coincidentally align with the minimum and maximum t values used to create the Curve. This also helps us understand its directionality.

It's important to note that Dynamo assumes that the domain of "t" values for a Curve is understood to be 0.0 to 1.0.

All Curves also possess a number of properties or characteristics which can be used to describe or analyze them. When the distance between the start and end points is zero, the curve is "closed." Also, every curve has a number of control-points, if all these points are located in the same plane, the curve is "planar." Some properties apply to the curve as a whole, while others only apply to specific points along the curve. For example, planarity is a global property while a tangent vector at a given t value is a local property.

Lines

Lines are the simplest form of Curves. They may not look curvy but they are in fact Curves - just without any curvature. There are a few different ways to create Lines, the most intuitive being from Point A to Point B. The shape of the Line AB will be drawn between the points but mathematically it extends infinitely in both directions.

When we connect two Lines together, we have a Polyline. Here we have a straightforward representation of what a Control Point is. Editing any of these point locations will change the shape of the Polyline. If the Polyline is closed, we have a Polygon. If the Polygon's edge lengths are all equal, it is described as regular.

Arcs, Circles, Ellipse Arcs, and Ellipses

As we add more complexity to the Parametric Functions that define a shape, we can take one step further from a Line to create an Arc, Circle, Ellipse Arc, or Ellipse by describing one or two radii. The differences between the Arc version and the Circle or Ellipse is only whether or not the shape is closed.

NURBS + Polycurves

NURBS (Non-uniform Rational Basis Splines) are mathematical representations that can accurately model any shape from a simple two dimensional Line, Circle, Arc, or Rectangle to the most complex three-dimensional free-form organic Curve. Because of their flexibility (relatively few control points, yet smooth interpolation based on Degree settings) and precision (bound by a robust math), NURBS models can be used in any process from illustration and animation to manufacturing.

Degree: The Degree of the Curve determines the range of influence the Control Points have on a Curve; where the higher the degree, the larger the range. The Degree is a positive whole number. This number is usually 1, 2, 3 or 5, but can be any positive whole number. NURBS lines and polylines are usually Degree 1 and most free-form Curves are Degree 3 or 5.

Control Points: The Control Points are a list of at least Degree+1 Points. One of the easiest ways to change the shape of a NURBS Curve is to move its Control Points.

Weight: Control Points have an associated number called a Weight. Weights are usually positive numbers. When a Curve’s Control Points all have the same weight (usually 1), the Curve is called non-rational, otherwise the Curve is called rational. Most NURBS curves are non-rational.

Knots: Knots are a list of (Degree+N-1) numbers, where N is the number of Control Points. The Knots are used together with the weights to control the influence of the Control Points on the resulting Curve. One use for Knots is to create kinks at certain points in the curve.

1. Degree = 1

2. Degree = 2

3. Degree = 3

Vector, Plane & Coordinates System in Dynamo

Vector

Vector is a representation of magnitude and direction, you can picture it as an arrow accelerating towards a particular direction at a given speed. It is a key component to our models in Dynamo. Note that, because they are in the Abstract category of "Helpers," when we create a Vector, we won't see anything in the Background Preview.

1. We can use a line as a stand in for a Vector preview.

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

Plane

Plane is a two dimensional surface, you can picture it as a flat surface that extends indefinitely. Each Plane has an Origin, X Direction, Y Direction, and a Z (Up) Direction.

1. Although they are abstract, Planes do have an origin position so we can locate them in space.

2. In Dynamo, Planes are rendered in the Background Preview.

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

Coordinate System

Coordinate system is a system to determine the location of points or other geometric elements. The image below explains how it looks like in Dynamo and what each color represents.

1. Although they are abstract, Coordinate Systems also have an origin position so we can locate them in space.

2. In Dynamo, Coordinate Systems are rendered in the Background Preview as a point (origin) and lines defining the axes (X is red, Y is green, and Z is blue following convention).

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

Deep Dive into...

Vectors, Planes, and Coordinate Systems make up the primary group of Abstract Geometry Types. They help us define location, orientation, and the spatial context for other geometry that describe shapes. If I say that I'm in New York City at 42nd Street and Broadway (Coordinate System), standing on the street level (Plane), looking North (Vector), I've just used these "Helpers" to define where I am. The same goes for a phone case product or a skyscraper - we need this context to develop our model.

Vector

A vector is a geometric quantity describing Direction and Magnitude. Vectors are abstract; ie. they represent a quantity, not a geometrical element. Vectors can be easily confused with Points because they both are composed of a list of values. There is a key difference though: Points describe a position in a given coordinate system while Vectors describe a relative difference in position which is the same as saying "direction."

If the idea of relative difference is confusing, think of the Vector AB as "I'm standing at Point A, looking toward Point B." The direction, from here (A) to there (B), is our Vector.

Breaking down Vectors further into their parts using the same AB notation:

1. The Start Point of the Vector is called the Base.

2. The **End Point **of the Vector is called the Tip or the Sense.

3. Vector AB is not the same as Vector BA - that would point in the opposite direction.

If you're ever in need of comic relief regarding Vectors (and their abstract definition), watch the classic comedy Airplane and listen for the oft-quoted tongue-in cheek line:

Roger, Roger. What's our vector, Victor?

Plane

Planes are two-dimensional abstract "Helpers." More specifically, Planes are conceptually “flat,” extending infinitely in two directions. Usually they are rendered as a smaller rectangle near their origin.

You might be thinking, "Wait! Origin? That sounds like a Coordinate System... like the one I use to model in my CAD software!"

And you're correct! Most modeling software take advantage of construction planes or "levels" to define a local two-dimensional context to draft in. XY, XZ, YZ -or- North, Southeast, Plan might sound more familiar. These are all Planes, defining an infinite "flat" context. Planes don't have depth, but they do help us describe direction as well -

Coordinate System

If we are comfortable with Planes, we are a small step away from understanding Coordinate Systems. A Plane has all the same parts as a Coordinate System, provided it is a standard "Euclidean" or "XYZ" Coordinate System.

There are other, however, alternative Coordinate Systems such as Cylindrical or Spherical. As we will see in later sections, Coordinate Systems can also be applied to other Geometry types to define a position on that geometry.

Add alternative coordinate systems - cylindrical, spherical

Mesh in Dynamo

What is Mesh?

In the field of computational modeling, Meshes are one of the most pervasive forms of representing 3D geometry. Mesh geometry is generally made of a collection of quadrilaterals or triangles, it can be a light-weight and flexible alternative to working with NURBS, and Meshes are used in everything from rendering and visualizations to digital fabrication and 3D printing.

Mesh Elements

Dynamo defines Meshes using a Face-Vertex data structure. At its most basic level, this structure is simply a collection of points which are grouped into polygons. The points of a Mesh are called vertices, while the surface-like polygons are called faces.

To create a Mesh we need a list of vertices and a system of grouping those vertices into faces called an index group.

1. List of vertices

2. List of index groups to define faces

Mesh Toolkit

Dynamo's mesh capabilities can be extended by installing the Mesh Toolkit package. The Dynamo Mesh Toolkit provides tools to import Meshes from external file formats, create a Mesh from Dynamo geometry objects, and manually build Meshes by their vertices and indices.

The library also provides tools to modify Meshes, repair Meshes, or extract horizontal slices for use in fabrication.

Visit Mesh Toolkit case studies for example on using this package.

Deep Dive into...

Mesh

A Mesh is a collection of quadrilaterals and triangles that represents a surface or solid geometry. Like Solids, the structure of a Mesh object includes vertices, edges, and faces. There are additional properties that make Meshes unique as well, such as normals.

1. Mesh vertices

2. Mesh edges *Edges with only one adjoining face are called "Naked." All other edges are "Clothed"

3. Mesh faces

Vertices + Vertex Normals

The vertices of a Mesh are simply a list of points. The index of the vertices is very important when constructing a Mesh, or getting information about the structure of a Mesh. For each vertex, there is also a corresponding vertex normal (vector) which describes the average direction of the attached faces and helps us understand the "in" and "out" orientation of the Mesh.

1. Vertices

2. Vertex Normals

Faces

A face is an ordered list of three or four vertices. The “surface” representation of a Mesh face is therefore implied according to the position of the vertices being indexed. We already have the list of vertices that make up the Mesh, so instead of providing individual points to define a face, we simply use the index of the vertices. This also allows us to use the same vertex in more than one face.

1. A quad face made with indices 0, 1, 2, and 3

2. A triangle face made with indices 1, 4, and 2 Note that the index groups can be shifted in their order - as long as the sequence is ordered in a counter-clockwise manner, the face will be defined correctly

Meshes versus NURBS Surfaces

How is Mesh geometry different from NURBS geometry? When might you want to use one instead of the other?

Parameterization

In a previous chapter, we saw that NURBS surfaces are defined by a series of NURBS curves going in two directions. These directions are labeled U and V, and allow a NURBs surface to be parameterized according to a two-dimensional surface domain. The curves themselves are stored as equations in the computer, allowing the resulting surfaces to be calculated to an arbitrarily small degree of precision. It can be difficult, however, to combine multiple NURBS surfaces together. Joining two NURBS surfaces will result in a polysurface, where different sections of the geometry will have different UV parameters and curve definitions.

1. Surface

2. Isoparametric (Isoparm) Curve

3. Surface Control Point

4. Surface Control Polygon

5. Isoparametric Point

6. Surface Frame

7. Mesh

8. Naked Edge

9. Mesh Network

10. Mesh Edges

11. Vertex Normal

12. Mesh Face / Mesh Face Normal

Meshes, on the other hand, are comprised of a discrete number of exactly defined vertices and faces. The network of vertices generally cannot be defined by simple UV coordinates, and because the faces are discrete the amount of precision is built into the Mesh and can only be changed by refining the Mesh and adding more faces. The lack of mathematical descriptions allows Meshes to more flexibly handle complex geometry within a single Mesh.

Local versus Global Influence

Another important difference is the extent to which a local change in Mesh or NURBS geometry affects the entire form. Moving one vertex of a Mesh only affects the faces that are adjacent to that vertex. In NURBS surfaces, the extent of the influence is more complicated and depends on the degree of the surface as well as the weights and knots of the control points. In general, however, moving a single control point in a NURBS surface creates a smoother, more extensive change in geometry.

1. NURBS Surface - moving a control point has influence that extends across the shape

2. Mesh geometry - moving a vertex has influence only on adjacent elements

One analogy that can be helpful is to compare a vector image (composed of lines and curves) with a raster image (composed of individual pixels). If you zoom into a vector image, the curves remain crisp and clear, while zooming into a raster image results in seeing individual pixels become larger. In this analogy, NURBS surfaces can be compared to a vector image because there is a smooth mathematical relationship, while a Mesh behaves similarly to a raster image with a set resolution.

Solids in Dynamo

What is Solid?

If we want to construct more complex models that cannot be created from a single surface or if we want to define an explicit volume, we must now venture into the realm of Solids (and Polysurfaces). Even a simple cube is complex enough to need six surfaces, one per face. Solids give access to two key concepts that Surfaces do not - a more refined topological description (faces, edges, vertices) and Boolean operations.

Boolean Operation to Create Spiky Ball Solid

You can use Boolean operations to modify solids. Let's use a few Boolean operations to create a spiky ball.

1. Sphere.ByCenterPointRadius: Create the base Solid.

2. Topology.Faces, Face.SurfaceGeometry: Query the faces of the Solid and convert to surface geometry—in this case, the Sphere has only one Face.

3. Cone.ByPointsRadii: Construct cones using points on the surface.

4. Solid.UnionAll: Union the Cones and the Sphere.

5. Topology.Edges: Query the edges of the new Solid

6. Solid.Fillet: Fillet the Edges of the spiky ball

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

Freezing

Boolean operations are complex and can be slow to calculate. You can use the "freeze" functionality to suspend the execution of selected nodes and affected downstream nodes.

1.Use the right-click contextual menu to Freeze the Solid Union operation

2. The selected node and all downstream nodes will preview in a light grey ghosted mode, and affected wires will be displayed as dashed lines. The affected geometry preview will also be ghosted. You can now change values upstream without calculating the boolean union.

3. To unfreeze the nodes, right-click and uncheck Freeze.

4. All affected nodes and associated geometry previews will update and revert to the standard preview mode.

Deep Dive into...

Solids

Solids consist of one or more Surfaces that contain volume by way of a closed boundary that defines "in" or "out." Regardless of how many of these Surfaces there are, they must form a "watertight" volume to be considered a Solid. Solids can be created by joining Surfaces or Polysurfaces together or by using operations such as loft, sweep, and revolve. Sphere, Cube, Cone and Cylinder primitives are also Solids. A Cube with at least one face removed counts as a Polysurface, which has some similar properties, but it is not a Solid.

1. A Plane is made of a single Surface and is not a Solid.

2. A Sphere is made of one Surface but is a Solid.

3. A Cone is made of two surfaces joined together to make a Solid.

4. A Cylinder is made of three surfaces joined together to make a Solid.

5. A Cube is made of six surfaces joined together to make a Solid.

Topology

Solids are made up of three types of elements: Vertices, Edges, and Faces. Faces are the surfaces that make up the Solid. Edges are the Curves that define the connection between adjacent faces, and vertices are the start and end points of those Curves. These elements can be queried using the Topology nodes.

1. Faces

2. Edges

3. Vertices

Operations

Solids can be modified by filleting or chamfering their edges to eliminate sharp corners and angles. The chamfer operation creates a ruled surface between two faces, while a fillet blends between faces to maintain tangency.

1. Solid Cube

2. Chamfered Cube

3. Filleted Cube

Boolean Operations

Solid Boolean operations are methods for combining two or more Solids. A single Boolean operation actually means performing four operations:

1. Intersect two or more objects.

2. Split them at the intersections.

3. Delete unwanted portions of the geometry.

4. Join everything back together.

1. Union: Remove the overlapping portions of the Solids and join them into a single Solid.

2. Difference: Subtract one Solid from another. The Solid to be subtracted is referred to as a tool. Note that you could switch which Solid is the tool to keep the inverse volume.

3. Intersection: Keep only the intersecting volume of the two Solids.

1. UnionAll: Union operation with sphere and outward-facing cones

2. DifferenceAll: Difference operation with sphere and inward-facing cones

Surfaces in Dynamo

What is Surface

We use Surface in model to represent objects we see in our three dimensional world. While Curves are not always planar ie. they are three dimensional, the space they define is always bound to one dimension. Surfaces give us another dimension and a collection of additional properties we can use within other modeling operations.

Surface at Parameter

Import and evaluate a Surface at a Parameter in Dynamo to see what kind of information we can extract.

1. Surface.PointAtParameter returns the Point at a given UV Coordinate

2. Surface.NormalAtParameter returns the Normal Vector at a given UV Coordinate

3. Surface.GetIsoline returns the Isoparametric Curve at a U or V Coordinate - note the isoDirection input.

Download the example files by clicking on the link below.

A full list of example files can be found in the Appendix.

Deep Dive into...

Surface

A Surface is a mathematical shape defined by a function and two parameters, Instead of t for Curves, we use U and V to describe the corresponding parameter space. This means we have more geometrical data to draw from when working with this type of Geometry. For example, Curves have tangent vectors and normal planes (which can rotate or twist along the curve's length), whereas Surfaces have normal vectors and tangent planes that will be consistent in their orientation.

1. Surface

2. U Isocurve

3. V Isocurve

4. UV Coordinate

5. Perpendicular Plane

6. Normal Vector

Surface Domain: A surface domain is defined as the range of (U,V) parameters that evaluate into a three dimensional point on that surface. The domain in each dimension (U or V) is usually described as two numbers (U Min to U Max) and (V Min to V Max).

Although the shape of the Surface by not look "rectangular" and it locally may have a tighter or looser set of isocurves, the "space" defined by its domain is always two dimensional. In Dynamo, Surfaces are always understood to have a domain defined by a minimum of 0.0 and maximum of 1.0 in both U and V directions. Planar or trimmed Surfaces may have different domains.

Isocurve (or Isoparametric Curve): A curve defined by a constant U or V value on the surface and a domain of values for the corresponding other U or V direction.

UV Coordinate: The Point in UV Parameter Space defined by U, V, and sometimes W.

Perpendicular Plane: A Plane that is perpendicular to both U and V Isocurves at a given UV Coordinate.

Normal Vector: A Vector defining the direction of "up" relative to the Perpendicular Plane.

NURBS Surfaces

NURBS Surfaces are very similar to NURBS curves. You can think of NURBS Surfaces as a grid of NURBS Curves that go in two directions. The shape of a NURBS Surface is defined by a number of control points and the degree of that surface in the U and V directions. The same algorithms are used to calculate shape, normals, tangents, curvatures and other properties by way of control points, weights and degree.

In the case of NURBS surfaces, there are two directions implied by the geometry, because NURBS surfaces are, regardless of the shape we see, rectangular grids of control points. And even though these directions are often arbitrary relative to the world coordinate system, we will use them frequently to analyze our models or generate other geometry based on the Surface.

1. Degree (U,V) = (3,3)

2. Degree (U,V) = (3,1)

3. Degree (U,V) = (1,2)

4. Degree (U,V) = (1,1)

Polysurfaces

Polysurfaces are composed of Surfaces that are joined across an edge. Polysurfaces offer more than two dimensional UV definition in that we can now move through the connected shapes by way of their Topology.

While "Topology" generally describes a concept around how parts are connected and/or related Topology in Dynamo is also a type of Geometry. Specifically it is a parent category for Surfaces, Polysurfaces, and Solids.

Sometimes called patches, joining Surfaces in this manner allows us to make more complex shapes as well as define detail across the seam. Conveniently we can apply a fillet or chamfer operation to the edges of a Polysurface.

Once we are ready to dive deeper into developing Visual Programs, we will need a deeper understanding of the building blocks we will use. This chapter introduces fundamental concepts around data - the stuff that travels through the Wires of our Dynamo program.

What is a String

Formally, a String is a sequence of characters representing a literal constant or some type of variable. Informally, a string is programming lingo for text. We've worked with numbers, both integers and decimal numbers, to drive parameters and we can do the same with text.

Creating Strings

Strings can be used for a wide range of applications, including defining custom parameters, annotating documentation sets, and parsing through text-based data sets. The string Node is located in the Core>Input Category.

The sample Nodes above are strings. A number can be represented as a string, as can a letter, or an entire array of text.

Exercise

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

Querying Strings

You can parse through large amounts of data quickly by querying strings. We'll talk about some basic operations which can speed up a workflow and help for software interoperability.

The image below considers a string of data coming from an external spreadsheet. The string represents the vertices of a rectangle in the XY-Plane. Let's break down some string split operations in miniature exercise:

1. The ";" separator splits each vertex of the rectangle. This creates a list with 3 items for each vertex.

1. By hitting the "+" in the middle of the Node, we create new separator.

2. Add a "," string to the canvas and plug in to the new separator input.

3. Our result is now a list of ten items. The Node first splits based on separator0, then based on separator1.

While the list of items above may look like numbers, they are still regarded as individual strings in Dynamo. In order to create points, their data type needs to be converted from a string to a number. This is done with the String.ToNumber Node

1. This Node is straightforward. Plug the String.Split results into the input. The output doesn't look different, but the data type is now a number instead of a string.

With some basic additional operations, we now have a triangle drawn at the origin based on the original string input.

Manipulating Strings

Since a string is a generic text object, they host a wide range of applications. Let's take a look at some of the major actions in the Core>String Category in Dynamo:

This is a method of merging two strings together in order. This takes each literal string in a list and creates one merged string.

The following represents the concatenation of three strings:

1. Add or subtract strings to the concatenation by clicking the +/- buttons in the center of the Node.

2. The output gives one concatenated string, with spaces and punctuation included.

The join method is very similar to concatenate, except it has an added layer of punctuation.

If you've worked in Excel, you may have come across a CSV file. This stands for comma-separated values. One could use a comma (or in this case, two dashes) as the separator with the String.Join node in order to create a similar data structure.

The following image represents the joining of two strings:

1. The separator input allows one to create a string which divides the joined strings.

Working with Strings

Let's begin with a basic string split of the stanza. We first notice that the writing is formatted based on commas. We'll use this format to separate each line into individual items.

1. The base string is pasted into a String Node.

2. Another String Node is used to denote the separator. In this case, we're using a comma.

3. A String.Split Node is added to the canvas and connected to the two strings.

4. The output shows that we've now separated the lines into individual elements.

Now, let's get to the good part of the poem: the last two lines. The original stanza was one item of data. We separated this data into individual items in the first step. Now we need to do a search for the text we're looking for. And while we can do this by selecting the last two items of the list, if this were an entire book, we wouldn't want to read through everything and manually isolate the elements.

1. Instead of manually searching, we use a String.Contains Node to perform a search for a set of characters. This is the similar to doing the "Find" command in a word processor. In this case, we get a return of "true" or "false" if that substring is found within the item.

2. In the searchFor input, we define a substring that we're looking for within the stanza. Let's use a String Node with the text "And miles".

3. The output gives us a list of falses and trues. We'll use this boolean logic to filter the elements in the next step.

1. List.FilterByBoolMask is the Node we want to use to cull out the falses and trues. The "in" output return the statements with a "mask" input of "true, while the "out" output return those which are "false".

2. Our output from the "in" is as expected, giving us the final two lines of the stanza.

Now, we want to drive home the repetition of the stanza by merging the two lines together. When viewing the output of the previous step, we notice that there are two items in the list:

1. Using two List.GetItemAtIndex Nodes, we can isolate the items using the values of 0 and 1 as the index input.

2. The output for each node gives us, in order, the final two lines.

To merge these two items into one, we use the String.Join Node:

1. After adding the String.Join Node, we notice that we need a separator.

2. To create the separator, we add a String Node to the canvas and type in a comma.

3. The final output has merged the last two items into one.

This may seem like a lot of work to isolate the last two lines; and it's true, string operations often require some up front work. But they are scalable, and they can be applied to large datasets with relative ease. If you are working parametrically with spreadsheets and interoperability, be sure to keep string operations in mind.

Geometry in Dynamo Sandbox

Geometry is the language for design. When a programming language or environment has a geometry kernel at its core, we can unlock the possibilities for designing precise and robust models, automating design routines, and generating design iterations with algorithms.

Additionally, making models in Dynamo and connecting the preview of what we see in the Background Preview to the flow of data in our graph should become more intuitive over time.

1. Note the assumed coordinate system rendered by the grid and colored axes

2. Selected Nodes will render the corresponding geometry (if the Node creates geometry) in the background the highlight color

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

The Concept of Geometry

Geometry, traditionally defined, is the study of shape, size, relative position of figures, and the properties of space. This field has a rich history going back thousands of years. With the advent and popularization of the computer, we gained a powerful tool in defining, exploring, and generating geometry. It is now so easy to calculate the result of complex geometric interactions, the fact that we are doing so is almost transparent.

If you're curious to see how diverse and complex geometry can get using the power of your computer, do a quick web search for the Stanford Bunny - a canonical model used to test algorithms.

Understanding geometry in the context of algorithms, computing, and complexity, may sound daunting; however, there are a few key, and relatively simple, principles that we can establish as fundamentals to start building towards more advanced applications:

1. Geometry is Data - to the computer and Dynamo, a Bunny not all that different from a number.

2. Geometry relies on Abstraction - fundamentally, geometric elements are described by numbers, relationships, and formulas within a given spatial coordinate system

3. Geometry has a Hierarchy - points come together to make lines, lines come together to make surfaces, and so on

4. Geometry simultaneously describes both the Part and the Whole - when we have a curve, it is both the shape as well as all the possible points along it

In practice, these principles mean that we need to be aware of what we are working with (what type of geometry, how was it created, etc.) so that we can fluidly compose, decompose, and recompose different geometries as we develop more complex models.

Stepping through the Hierarchy

Let's take a moment to look at the relationship between the Abstract and Hierarchical descriptions of Geometry. Because these two concepts are related, but not always obvious at first, we can quickly arrive at a conceptual roadblock once we start developing deeper workflows or models. For starters, let's use dimensionality as an easy descriptor of the "stuff" we model. The number of dimensions required to describe a shape gives us a window into how Geometry is organized hierarchically.

1. A Point (defined by coordinates) doesn't have any dimensions to it - it's just numbers describing each coordinate

2. A Line (defined by two points) now has one dimension - we can "walk" the line either forward (positive direction) or backward (negative direction)

3. A Plane (defined by two lines) has two dimensions - walking more left or more right is now possible

4. A Box (defined by two planes) has three dimensions - we can define a position relative to up or down

Dimensionality is a convenient way to start categorizing Geometry but it's not necessarily the best. After all, we don't model with only Points, Lines, Planes, and Boxes - what if I want something curvy? Furthermore, there is a whole other category of Geometric types that are completely abstract ie. they define properties like orientation, volume, or relationships between parts. We can't really grab a hold of a Vector so how do we define it relative to what we see in space? A more detailed categorization of the geometric hierarchy should accommodate the difference between Abstract Types or "Helpers," each of which we can group by what they help do and types that help describe the shape of model elements.

Going Further with Geometry

Creating models in Dynamo is not limited to what we can generate with Nodes. Here are some key ways to take your process to the next level with Geometry:

1. Dynamo allows you to import files - try using a CSV for point clouds or SAT for bringing in surfaces

2. When working with Revit, we can reference Revit elements to use in Dynamo

Logic, or more specifically, Conditional Logic, allows us to specify an action or set of actions based on a test. After evaluating the test, we will have a Boolean value representing True or False that we can use to control the Program Flow.

Booleans

Numeric variables can store a whole range of different numbers. Boolean variables can only store two values referred to as True or False, Yes or No, 1 or 0. We rarely use booleans to perform calculations because of their limited range.

Conditional Statements

The "If" statement is a key concept in programming: "If this is true, then that happens, otherwise something else happens. The resulting action of the statement is driven by a boolean value. There are multiple ways to define an "If" statement in Dynamo:

Let's go over a brief example on each of these three nodes in action using the conditional "If" statement.

In this image, the boolean is set to true, which means that the result is a string reading: "this is the result if true". The three Nodes creating the If statement are working identically here.

Again, the Nodes are working identically. If the boolean is changed to false, our result is the number Pi, as defined in the original If statement.

Exercise: Logic and Geometry

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

Part I: Filtering a List

1. Let's use logic to separate a list of numbers into a list of even numbers and a list of odd numbers.

a. Number Range - add a number range to the canvas.

b. Numbers - add three number nodes to the canvas. The value for each number node should be: 0.0 for start, 10.0 for end, and 1.0 for step.

c. Output - our output is a list of 11 numbers ranging from 0-10.

d. Modulo (%)- Number Range into x and 2.0 into y. This calculates the remainder for each number in the list divided by 2. The output from this list gives us a list of values alternating between 0 and 1.

e. Equality Test (==) - add an equality test to the canvas. Plug modulo output into the x input and 0.0 into the y input.

f. Watch - The output of the equality test is a list of values alternating between true and false. These are the values used to separate the items in the list. 0 (or true) represents even numbers and (1, or false) represents odd numbers.

g. List.FilterByBoolMask - this Node will filter the values into two different lists based on the input boolean. Plug the original number range into the list input and the equality test output into the mask input. The in output represents true values while the out output represents false values.

h. Watch - as a result, we now have a list of even numbers and a list of odd numbers. We've used logical operators to separate lists into patterns!

Part II: From Logic to Geometry

Building off of the logic established in the first exercise, let's apply this setup into a modeling operation.

2. We'll jump off from the previous exercise with the same Nodes. The only exceptions (in addition to changing the format are):

a. Use a Sequence Node with these input values.

b. We've unplugged the in list input into List.FilterByBoolMask. We'll put these Nodes aside for now, but they'll come in handy later in the exercise.

3. Let's begin by creating a separate group of Graph as shown in the image above. This group of Nodes represents a parametric equation to define a line curve. A few notes:

a. The first Number Slider represents the frequency of the wave, it should have a min of 1, a max of 4, and a step of 0.01.

b. The second Number Slider represents the amplitude of the wave, should have a min of 0, a max of 1, and a step of 0.01.

c. PolyCurve.ByPoints - if the above Node diagram is copied, the result is a sine curve in the Dynamo Preview viewport.

The method here for the inputs: use number nodes for more static properties and number sliders on the more flexible ones. We want to keep the original number range that we're defining in the beginning of this step. However, the sine curve that we create here should have some flexibility. We can move these sliders to watch the curve update its frequency and amplitude.

4. We're going to jump around a bit in the definition, so let's look at the end result so that we can reference what we're getting at. The first two steps are made separately, we now want to connect the two. We'll use the base sine curve to drive the location of the zipper components, and we'll use the true/false logic to alternate between little boxes and larger boxes.

a. Math.RemapRange - Using the number sequence created in step 02, let's create a new series of numbers by remapping the range. The original numbers from step 01 range from 0-100. These numbers range from 0 to 1 by the newMin and newMax inputs respectively.

5. Create a Curve.PointAtParameter Node, then connect the Math.RemapRange output from step 04 as its param input.

This step creates points along the curve. We remapped the numbers to 0 to 1 because the input of param is looking for values in this range. A value of 0 represents the start point, a value of 1 represents the end points. All numbers in between evaluate within the [0,1] range.

6. Connect the output from Curve.PointAtParameter to the List.FilterByBoolMask to separate the list of odd and even indices.

a. List.FilterByBoolMask - Plug Curve.PointAtParameter from the previous step into the list input.

b. Watch - a watch node for in and a watch node for out shows that we have two lists representing even indices and odd indices. These points are ordered in the same way on the curve, which we demonstrate in the next step.

7. Next, we are going to use the output result from List.FilterByBoolMask in step 05 to generate geometries with sizes according to its indices.

Cuboid.ByLengths - recreate the connections seen in the image above to get a zipper along the sine curve. A cuboid is just a box here, and we're defining its size based on the curve point in the center of the box. The logic of the even/odd divide should now be clear in the model.

a. List of cuboids at even indices.

b. List of cuboids at odd indices.

Voila! You have just programmed a process of defining the geometry dimensions according to the logic operation demonstrated in this exercise.

Working with Lists

Now that we've established what a list is, let's talk about operations we can perform on it. Imagine a list as a deck of playing cards. A deck is the list and each playing card represents an item.

Query

What queries can we make from the list? This accesses existing properties.

• Number of cards in the deck? 52.

• Number of suits? 4.

• Material? Paper.

• Length? 3.5" or 89mm.

• Width? 2.5" or 64mm.

Action

What actions can we perform on the list? This changes the list based on a given operation.

• We can shuffle the deck.

• We can sort the deck by value.

• We can sort the deck by suit.

• We can split the deck.

• We can partition the deck by dealing out individual hands.

• We can select a specific card in the deck.

All of the operations listed above have analogous Dynamo nodes for working with lists of generic data. The lessons below will demonstrate some of the fundamental operations we can perform on lists.

Exercise

List Operations

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

The image below is the base graph which we are drawing lines between two circles to represent basic list operations. We'll explore how to manage data within a list and demonstrate the visual results through the list actions below.

1. Begin with a Code Block with a value of 500;

2. Plug into the x input of a Point.ByCoordinates node.

3. Plug the node from the previous step into the origin input of a Plane.ByOriginNormal node.

4. Using a Circle.ByPlaneRadius node, plug the node from the previous step into the plane input.

5. Using Code Block, designate a value of 50; for the radius. This is the first circle we'll create.

6. With a Geometry.Translate node, move the circle up 100 units in the Z direction.

7. With a Code Block node, define a range of ten numbers between 0 and 1 with this line of code: 0..1..#10;

8. Plug the code block from the previous step into the param input of two Curve.PointAtParameter nodes. Plug Circle.ByPlaneRadius into the curve input of the top node, and Geometry.Translate into the curve input of the node beneath it.

9. Using a Line.ByStartPointEndPoint, connect the two Curve.PointAtParameter nodes.

List.Count

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

The List.Count node is straightforward: it counts the number of values in a list and returns that number. This node gets more nuanced as we work with lists of lists, but we'll demonstrate that in the coming sections.

1. The **List.Count ****** node returns the number of lines in the Line.ByStartPointEndPoint node. The value is 10 in this case, which agrees with the number of points created from the original Code Block node.

List.GetItemAtIndex

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

List.GetItemAtIndex is a fundamental way to query an item in the list.

1. First, Right click on Line.ByStartPointEndPoint node to switch off its preview.

2. Using the List.GetItemAtIndex node, we are selecting index "0", or the first item in the list of lines.

Change slider value between 0 and 9 to select different item using List.GetItemAtIndex.

List.Reverse

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

List.Reverse reverses the order of all of the items in a list.

1. To properly visualize the reversed list of lines, create more lines by changing the Code Block to 0..1..#50;

2. Duplicate the Line.ByStartPointEndPoint node, insert a List.Reverse node in between Curve.PointAtParameter and the second Line.ByStartPointEndPoint

3. Use Watch3D nodes to preview two different results. The first one shows the result without a reversed list. The lines connect vertically to neighboring points. The reversed list, however, will connect all of the points to the opposing order in the other list.

List.ShiftIndices

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

List.ShiftIndices is a good tool for creating twists or helical patterns, or any other similar data manipulation. This node shifts the items in a list a given number of indices.

1. In the same process as the reverse list, insert a List.ShiftIndices into the Curve.PointAtParameter and Line.ByStartPointEndPoint.

2. Using a Code Block, designated a value of "1" to shift the list one index.

3. Notice that the change is subtle, but all of the lines in the lower Watch3D node have shifted one index when connecting to the other set of points.

By changing to Code Block to a larger value, "30" for example, we notice a significant difference in the diagonal lines. The shift is working like a camera's iris in this case, creating a twist in the original cylindrical form.

List.FilterByBooleanMask

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

List.FilterByBooleanMask will remove certain items based on a list of booleans, or values reading "true" or "false".

In order to create a list of values reading "true" or "false", we need to a little more work...

1. Using a Code Block, define an expression with the syntax: 0..List.Count(list);. Connect the Curve.PointAtParameter node to the list input. We'll walk through this setup more in the code block chapter, but the line of code in this case is giving us a list representing each index of the Curve.PointAtParameter node.

2. Using a %** (modulus)** node, connect the output of the code block into the x input, and a value of 4 into the y input. This will give us the remainder when dividing the list of indices by 4. Modulus is a really helpful node for pattern creation. All values will read as the possible remainders of 4: 0, 1, 2, 3.

3. From the %** (modulus)** node, we know that a value of 0 means that the index is divisible by 4 (0,4,8,etc...). By using a == node, we can test for the divisibility by testing it against a value of "0".

4. The Watch node reveals just this: we have a true/false pattern which reads: true,false,false,false....

5. Using this true/false pattern, connect to the mask input of two List.FilterByBooleanMask nodes.

6. Connect the Curve.PointAtParameter node into each list input for the List.FilterByBooleanMask.

7. The output of Filter.ByBooleanMask reads "in" and "out". "In" represents values which had a mask value of "true" while "out" represents values which had a value of "false". By plugging the "in" outputs into the startPoint and endPoint inputs of a Line.ByStartPointEndPoint node, we've created a filtered list of lines.

8. The Watch3D node reveals that we have fewer lines than points. We've selected only 25% of the nodes by filtering only the true values!

Lists are the way we organize data. On your computer's operating system, you have files and folders. In Dynamo, we can regard these as items and lists, respectively. Like your operating system, there are many ways to create, modify, and query data. In this chapter, we'll break down how lists are managed in Dynamo.

Points in Dynamo

What is a Point?

2D & 3D Point

The most common kind of Point in Dynamo exists in our three-dimensional World Coordinate System and has three coordinates [X,Y,Z] (3D Point in Dynamo).

A 2D Point in Dynamo has two coordinates [X,Y].

Point on Curves and Surfaces

Parameters for both Curves and Surfaces are continuous and extend beyond the edge of the given geometry. Since the shapes that define the Parameter Space reside in a three-dimensional World Coordinate System, we can always translate a Parametric Coordinate into a "World" Coordinate. The point [0.2, 0.5] on the surface for example is the same as point [1.8, 2.0, 4.1] in world coordinates.

1. Point in assumed World XYZ Coordinates

2. Point relative to a given Coordinate System (Cylindrical)

3. Point as UV Coordinate on a Surface

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

Deep Dive into...

If Geometry is the language of a model, then Points are the alphabet. Points are the foundation upon which all other geometry is created - we need at least two Points to create a Curve, we need at least three Points to make a Polygon or a Mesh Face, and so on. Defining the position, order, and relationship among Points (try a Sine Function) allows us to define higher order geometry like things we recognize as Circles or Curves.

1. A Circle using the functions x=r*cos(t) and y=r*sin(t)

2. A Sine Curve using the functions x=(t) and y=r*sin(t)

Point as Coordinates

Points can exist in a two-dimensional Coordinate System as well. Convention has different letter notation depending upon what kind of space we are working with - we might be using [X,Y] on a Plane or [U,V] if we are on a surface.

1. A Point in Euclidean Coordinate System: [X,Y,Z]

2. A Point in a Curve Parameter Coordinate System: [t]

3. A Point in a Surface Parameter Coordinate System: [U,V]

Color is a great data type for creating compelling visuals as well as for rendering difference in the output from your Visual Program. When working with abstract data and varying numbers, sometimes it's difficult to see what's changing and to what degree. This is a great application for colors.

Creating Colors

Colors in Dynamo are created using ARGB inputs.This corresponds to the Alpha, Red, Green, and Blue channels. The alpha represents the transparency of the color, while the other three are used as primary colors to generate the whole spectrum of color in concert.

Querying Color Values

The colors in the table below query the properties used to define the color: Alpha, Red, Green, and Blue. Note that the Color.Components Node gives us all four as different outputs, which makes this Node preferable for querying the properties of a color.

The colors in the table below correspond to the HSB color space. Dividing the color into hue, saturation, and brightness is arguably more intuitive for how we interpret color: What color should it be? How colorful should it be? And how light or dark should the color be? This is the breakdown of hue, saturation, and brightness respectively.

Color Range

The current Node works well, but it can be a little awkward to get everything working the first time around. The best way to become familiar with the color gradient is to test it out interactively. Let's do a quick exercise to review how to setup a gradient with output colors corresponding to numbers.

1. Define three colors: Using a Code Block node, define red, green, and blue by plugging in the appropriate combinations of 0 and 255.

2. Create list: Merge the three colors into one list.

3. Define Indices: Create a list to define the grip positions of each color (ranging from 0 to 1). Notice the value of 0.75 for green. This places the green color 3/4 of the way across the horizontal gradient in the color range slider.

4. Code Block: Input values (between 0 and 1) to translate to colors.

Color Preview

The Display.ByGeometry Node gives us the ability to color geometry in the Dynamo viewport. This is helpful for separating different types of geometry, demonstrating a parametric concept, or defining an analysis legend for simulation. The inputs are simple: geometry and color. To create a gradient like the image above, the color input is connected to the Color Range Node.

Color On Surfaces

The Display.BySurfaceColors node gives us the ability to map data across a surface using color! This functionality introduces some exciting possibilities for visualizing data obtained through discrete analysis like solar, energy, and proximity. Applying color to a surface in Dynamo is similar to applying a texture to a material in other CAD environments. Let's demonstrate how to use this tool in the brief exercise below.

Exercise

Basic Helix with Colors

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

This exercise focuses on controlling color parametrically in parallel with geometry. The geometry is a basic helix, which we define below using the Code Block. This is a quick and easy way to create a parametric function; and since our focus is on color (rather than geometry), we use the code block to efficiently create the helix without cluttering the canvas. We will use the code block more frequently as the primer moves to more advanced material.

1. Code Block: Define the two code blocks with the formulas above. This is a quick parametric method for creating a spiral.

2. Point.ByCoordinates: Plug the three outputs from the code block into the coordinates for the Node.

We now see an array of points creating a helix. The next step is to create a curve through the points so that we can visualize the helix.

1. PolyCurve.ByPoints: Connect the Point.ByCoordinates output into the points input for the Node. We get a helical curve.

2. Curve.PointAtParameter: Connect the PolyCurve.ByPoints output into the curve input. The purpose of this step is to create a parametric attractor point which slides along the curve. Since the curve is evaluating a point at parameter, we'll need to input a param value between 0 and 1.

3. Number Slider: After adding to the canvas, change the min value to 0.0, the max value to 1.0, and the step value to .01. Plug the slider output into the param input for Curve.PointAtParameter. We now see a point along the length of the helix, represented by a percentage of the slider (0 at the start point, 1 at the end point).

With the reference point created, we now compare the distance from the reference point to the original points defining the helix. This distance value will drive geometry as well as color.

1. Geometry.DistanceTo: Connect Curve.PointAtParameter output into the input. Connect Point.ByCoordinates into the geometry input.

2. Watch: The resultant output shows a list of distances from each helical point to the reference point along the curve.

Our next step is to drive parameters with the list of distances from the helical points to the reference point. We use these distance values to define the radii of a series of spheres along the curve. In order to keep the spheres a suitable size, we need to remap the values for distance.

1. Math.RemapRange: Connect Geometry.DistanceTo output into the numbers input.

2. Code Block: connect a code block with a value of 0.01 into the newMin input and a code block with a value of 1 into the newMax input.

3. Watch: connect the Math.RemapRange output into one node and the Geometry.DistanceTo output into another. Compare the results.

This step has remapped the list of distance to be a smaller range. We can edit the newMin and newMax values however we see fit. The values will remap and will have the same distribution ratio across the domain.

1. Sphere.ByCenterPointRadius: connect the Math.RemapRange output into the radius input and the original Point.ByCoordinates output into the centerPoint input.

Change the value of the number slider and watch the size of the spheres update. We now have a parametric jig

The size of the spheres demonstrates the parametric array defined by a reference point along the curve. Let's use the same concept for the sphere radius to drive their color.

1. Color Range: Add top the canvas. When hovering over the value input, we notice that the numbers requested are between 0 and 1. We need to remap the numbers from the Geometry.DistanceTo output so that they are compatible with this domain.

2. Sphere.ByCenterPointRadius: For the time being, let's disable the preview on this node (Right Click > Preview)

1. Math.RemapRange: This process should look familiar. Connect the Geometry.DistanceTo output into the numbers input.

2. Code Block: Similar to an earlier step, create a value of 0 for the newMin input and a value of 1 for the newMax input. Notice that we are able to define two outputs from one code block in this case.

3. Color Range: Connect the Math.RemapRange output into the value input.

1. Color.ByARGB: This is what we'll do to create two colors. While this process may look awkward, it's the same as RGB colors in another software, we're just using visual programming to do it.

2. Code Block: create two values of 0 and 255. Plug the two outputs into the two Color.ByARGB inputs in agreement with the image above (or create your favorite two colors).

3. Color Range: The colors input requests a list of colors. We need to create this list from the two colors created in the previous step.

4. List.Create: merge the two colors into one list. Plug the output into the colors input for Color Range.

1. Display.ByGeometryColor: Connect Sphere.ByCenterPointRadius into the geometry input and the Color Range into the color input. We now have a smooth gradient across the domain of the curve.

If we change the value of the Number Slider from earlier in the definition, the colors and sizes update. Colors and radius size are directly related in this case: we now have a visual link between two parameters!

Color on Surfaces Exercise

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

First, we need to create (or reference) a surface to use as an input for the Display.BySurfaceColors node. For this example we are lofting between a sine and cosine curve.

1. This group of nodes is creating points along the Z-axis then displacing them based on sine and cosine functions. The two point lists are then used to generate NURBS curves.

2. Surface.ByLoft: generate an interpolated surface between the list of NURBS curves.

1. File Path: select an image file to sample for pixel data downstream

2. use File.FromPath to convert the file path to a file then pass into Image.ReadFromFile to output an image for sampling

3. Image.Pixels: input an image and provide a sample value to use along the x and y dimensions of the image.

4. Slider: provide sample values for Image.Pixels

5. Display.BySurfaceColors: map array of color values across surface along X and Y respectively

Close-up preview of the output surface with resolution of 400x300 samples

Data is the stuff of our programs. It travels through Wires, supplying inputs for Nodes where it gets processed into a new form of output data. Let's review the definition of data, how it's structured, and begin using it in Dynamo.

What is Data?

Data is a set of values of qualitative or quantitative variables. The simplest form of data is numbers such as 0, 3.14, or 17. But data can also be of a number of different types: a variable representing changing numbers (height); characters (myName); geometry (Circle); or a list of data items (1,2,3,5,8,13,...).

In Dynamo, we add/feed data to the input Ports of Nodes - we can have data without actions but we need data to process the actions that our Nodes represent. When we've added a Node to the Workspace, if it doesn't have any inputs supplied, the result will be a function, not the result of the action itself.

1. Simple Data

2. Data and Action (A Node) successfully executes

3. Action (A Node) without Data Inputs returns a generic function

Null - Absence of Data

Beware of Nulls The 'null' type represents the absence of data. While this is an abstract concept, you will likely come across this while working with Visual Programming. If an action doesn't create a valid result, the Node will return a null.

Testing for nulls and removing nulls from data structure is a crucial part to creating robust programs.

Data Structures

When we are Visual Programming, we can very quickly generate a lot of data and require a means of managing its hierarchy. This is the role of Data Structures, the organizational schemes in which we store data. The specifics of Data Structures and how to use them vary from programming language to programming language.

In Dynamo, we add hierarchy to our data through Lists. We will explore this in depth in later chapters, but let's start simply:

A list represents a collection of items placed into one structure of data:

• I have five fingers (items) on my hand (list).

• There are ten houses (items) on my street (list).

1. A Number Sequence node defines a list of numbers by using a start, amount, and step input. With these nodes, we've created two separate lists of ten numbers, one which ranges from 100-109 and another which ranges from 0-9.

2. The List.GetItemAtIndex node selects an item in a list at a specific index. When choosing 0, we get the first item in the list (100 in this case).

3. Applying the same process to the second list, we get a value of 0, the first item in the list.

4. Now we merge the two lists into one by using the List.Create node. Notice that the node creates a list of lists. This changes the structure of the data.

5. When using List.GetItemAtIndex again, with index set to 0, we get the first list in the list of lists. This is what it means to treat a list as an item, which is somewhat different from other scripting languages. We will get more advanced with list manipulation and data structure in later chapters.

The key concept to understand about data hierarchy in Dynamo: with respect to data structure, lists are regarded as items. In other words, Dynamo functions with a top-down process for understanding data structures. What does this mean? Let's walk through it with an example.

Exercise: Using Data to Make a Chain of Cylinders

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

In this first example, we assemble a shelled cylinder which walks through the geometry hierarchy discussed in this section.

Part I: Set up Graph for one cylinder with some changeable parameters.

1.Add Point.ByCoordinates - after adding the node to canvas, we see a point at the origin of the Dynamo preview grid. The default values of the x,y, and z inputs are 0.0, giving us a point at this location.

2. Plane.ByOriginNormal - The next step in the geometry hierarchy is a plane. There are several ways to construct a plane, and we are using an origin and normal for the input. The origin is the point node created in the previous step.

Vector.ZAxis - this is a unitized vector in the z direction. Notice there are not inputs, only a vector of [0,0,1] value. We use this as the normal input for the Plane.ByOriginNormal node. This gives us a rectangular plane in the Dynamo preview.

3. Circle.ByPlaneRadius - Stepping up the hierarchy, we now create a curve from the plane in our previous step. After plugging into the node, we get a circle at the origin. The default radius on the node is value of 1.

4. Curve.Extrude - Now we make this thing pop by giving it some depth and going in the third dimension. This node creates a surface from a curve by extruding it. The default distance on the node is 1, and we should see a cylinder in the viewport.

5. Surface.Thicken - This node gives us a closed solid by offsetting the surface a given distance and closing the form. The default thickness value is 1, and we see a shelled cylinder in the viewport in line with these values.

6. Number Slider - Rather than using the default values for all of these inputs, let's add some parametric control to the model.

Domain Edit - after adding the number slider to the canvas, click the caret in the top left to reveal the domain options.

Min/Max/Step - change the min, max, and step values to 0,2, and 0.01 respectively. We are doing this to control the size of the overall geometry.

7. Number Sliders - In all of the default inputs, let's copy and paste this number slider (select the slider, hit Ctrl+C, then Ctrl+V) several times, until all of the inputs with defaults have a slider instead. Some of the slider values will have to be larger than zero to get the definition to work (ie: you need an extrusion depth in order to have a surface to thicken).

8. We've now created a parametric shelled cylinder with these sliders. Try to flex some of these parameters and see the geometry update dynamically in the Dynamo viewport.

Number Sliders - taking this a step further, we've added a lot of sliders to the canvas, and need to clean up the interface of the tool we just created. Right click on one slider, select "Rename..." and change each slider to the appropriate name for its parameter (thickness, Radius, Height, etc).

Part II: Populate an array of cylinders from Part I

9. At this point, we've created an awesome thickening cylinder thing. This is one object currently, let's look at how to create an array of cylinders that remains dynamically linked. To do this, we're going to create a list of cylinders, rather than working with a single item.

Addition (+) - Our goal is to add a row of cylinders next to the cylinder we've created. If we want to add one cylinder adjacent to the current one, we need to consider both radius of the cylinder and the thickness of its shell. We get this number by adding the two values of the sliders.

10. This step is more involved so let's walk through it slowly: the end goal is to create a list of numbers which define the locations of each cylinder in a row.

a. Multiplication - First, we want to multiply the value from the previous step by 2. The value from the previous step represents a radius, and we want to move the cylinder the full diameter.

b. Number Sequence - we create an array of numbers with this node. The first input is the multiplication node from the previous step into the step value. The start value can be set to 0.0 using a number node.

c. Integer Slider - For the amount value, we connect an integer slider. This will define how many cylinders are created.

d. Output - This list shows us the distance moved for each cylinder in the array, and is parametrically driven by the original sliders.

11. This step is simple enough - plug the sequence defined in the previous step into the x input of the original Point.ByCoordinates. This will replace the slider pointX which we can delete. We now see an array of cylinders in the viewport (make sure the integer slider is larger than 0).

12. The chain of cylinders is still dynamically linked to all of the sliders. Flex each slider to watch the definition update!

If the simplest form of data is numbers, the easiest way to relate those numbers is through Mathematics. From simple operators like divide to trigonometric functions, to more complex formulas, Math is a great way to start exploring numeric relationships and patterns.

Arithmetic Operators

Operators are a set of components that use algebraic functions with two numeric input values, which result in one output value (addition, subtraction, multiplication, division, etc.). These can be found under Operators>Actions.

Exercise: The Golden Spiral Formula

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

Part I: Parametric Formula

Combine operators and variables to form a more complex relationship through Formulas. Use sliders to make a Formula that can be controlled with input parameters.

1.Create Number sequence that represents the 't' in the parametric equation, so we want to use a list that's large enough to define a spiral.

Number Sequence: define a number sequence based on three inputs: start, amount and step.

2. The step above has created a list of numbers to define the parametric domain. Next, create group of Nodes represent the golden spiral equation.

The golden spiral is defined as the equation:

The image below represents the golden spiral in in visual programming form. When stepping through the group of Nodes, try to pay attention to the parallel between the visual program and written equation.

a. Number Slider: Add two number sliders to the canvas. These sliders will represent the a and the b variables of the parametric equation. These represent a constant which is flexible, or parameters which we can adjust towards a desired outcome.

b. Multiplication (*) : The multiplication Node is represented by an asterisk. We'll use this repeatedly to connect multiplying variables

c. Math.RadiansToDegrees: The 't' values need to be translated to degrees for their evaluation in the trigonometric functions. Remember, Dynamo defaults to degrees for evaluating these functions.

d. Math.Pow: as a function of the 't' and the number 'e' this creates the Fibonacci sequence.

e. Math.Cos and Math.Sin: These two trigonometric functions will differentiate the x-coordinate and the y-coordinate, respectively, of each parametric point.

f. Watch: We now see that our output is two lists, these will be the x and y coordinates of the points used to generate the spiral.

Part II: From Formula to Geometry

Point.ByCoordinates: Connect the upper multiplication node into the 'x' input and the lower into the 'y' input. We now see a parametric spiral of points on the screen.

Polycurve.ByPoints: Connect Point.ByCoordinates from the previous step into points. We can leave connectLastToFirst without an input because we aren't making a closed curve. This creates a spiral which passes through each point defined in the previous step.

We've now completed the Fibonacci Spiral! Let's take this further into two separate exercises from here, which we'll call the Nautilus and the Sunflower. These are abstractions of natural systems, but the two different applications of the Fibonacci spiral will be well represented.

Part III: From Spiral to Nautilus

Circle.ByCenterPointRadius: We'll use a circle Node here with the same inputs as the previous step. The radius value defaults to 1.0, so we see an immediate output of circles. It becomes immediately legible how the points diverge further from the origin.

Number Sequence: This is the original array of 't'. By plugging this into the radius value of Circle.ByCenterPointRadius, the circle centers are still diverging further from the origin, but the radius of the circles is increasing, creating a funky Fibonacci circle graph.

Bonus points if you make it 3D!

Part IV: From Nautilus to Phyllotaxis

As a jumping-off point, let's start with the same step from the previous exercise: creating a spiral array of points with the Point.ByCoordinates Node.


Next, follow these mini steps to generate a series of spiral at various rotation.

a. Geometry.Rotate: There are several Geometry.Rotate options; be certain you've chosen the Node with geometry,basePlane, and degrees as its inputs. Connect Point.ByCoordinates into the geometry input. Right click on this Node and make sure the lacing is set to 'Cross Product'

b. Plane.XY: Connect to the basePlane input. We will rotate around the origin, which is the same location as the base of the spiral.

c. Number Range: For our degree input, we want to create multiple rotations. We can do this quickly with a Number Range component. Connect this into the degrees input.

d. Number: And to define the range of numbers, add three number nodes to the canvas in vertical order. From top to bottom, assign values of 0.0,360.0, and 120.0 respectively. These are driving the rotation of the spiral. Notice the output results from the Number Range node after connecting the three number nodes to the Node.

Our output is beginning to resemble a whirlpool. Let's adjust some of the Number Range parameters and see how the results change.

Change the step size of the Number Range node from 120.0 to 36.0. Notice that this is creating more rotations and is therefore giving us a denser grid.

Change the step size of the Number Range node from 36.0 to 3.6. This now gives us a much denser grid, and the directionality of the spiral is unclear. Ladies and gentlemen, we've created a sunflower.

What's a List?

A list is a collection of elements, or items. Take a bunch of bananas, for example. Each banana is an item within the list (or bunch). It's easier to pick up a bunch of bananas rather than each banana individually, and the same holds for grouping elements by parametric relationships in a data structure.

When we buy groceries, we put all of the purchased items into a bag. This bag is also a list. If we're making banana bread, we need 3 bunches of bananas (we're making a lot of banana bread). The bag represents a list of banana bunches and each bunch represents a list of bananas. The bag is a list of lists (two-dimensional) and the banana bunch is a list (one-dimensional).

In Dynamo, list data is ordered, and the first item in each list has an index "0". Below, we'll discuss how lists are defined in Dynamo and how multiple lists relate to one another.

Zero-Based Indices

One thing that might seem odd at first is that the first index of a list is always 0; not 1. So, when we talk about the first item of a list, we actually mean the item that corresponds to index 0.

For example, if you were to count the number of fingers we have on our right hand, chances are that you would have counted from 1 to 5. However, if you were to put your fingers in a list, Dynamo would have given them indices from 0 to 4. While this may seem a little strange to programming beginners, the zero-based index is standard practice in most computation systems.

Note that we still have 5 items in the list; it's just that the list is using a zero-based counting system. And the items being stored in the list don't just have to be numbers. They can be any data type that Dynamo supports, such as points, curves, surfaces, families, etc.

a. Index

b. Point

c. Item

Often times the easiest way to take a look at the type of data stored in a list is to connect a watch node to another node's output. By default, the watch node automatically shows all indices to the left side of the list and displays the data items on the right.

These indices are a crucial element when working with lists.

Inputs and Outputs

Pertaining to lists, inputs and outputs vary depending on the Dynamo node being used. As an example, let's use a list of 5 points and connect this output to two different Dynamo nodes: PolyCurve.ByPoints and Circle.ByCenterPointRadius:

1. The points input for PolyCurve.ByPoints is looking for "Point[]". This represents a list of points

2. The output for PolyCurve.ByPoints is a single polycurve created from a list of five point.

3. The centerPoint input for Circle.ByCenterPointRadius asks for "Point".

4. The output for Circle.ByCenterPointRadius is a list of five circles, whose centers correspond to the original list of points.

The input data for PolyCurve.ByPoints and Circle.ByCenterPointRadius are the same, however the Polycurve.ByPoints node gives us one polycurve while the Circle.ByCenterPointRadius node gives us 5 circles with centers at each point. Intuitively this makes sense: the polycurve is drawn as a curve connecting the 5 points, while the circles create a different circle at each point. So what's happening with the data?

Hovering over the points input for Polycurve.ByPoints, we see that the input is looking for "Point[]". Notice the brackets at the end. This represents a list of points, and to create a polycurve, the input needs to be a list for each polycurve. This node will therefore condense each list into one polycurve.

On the other hand, the centerPoint input for Circle.ByCenterPointRadius asks for "Point". This node looks for one point, as an item, to define the center point of the circle. This is why we get five circles from the input data. Recognizing these difference with inputs in Dynamo helps to better understand how the nodes are operating when managing data.

Lacing

Data matching is a problem without a clean solution. It occurs when a node has access to differently sized inputs. Changing the data matching algorithm can lead to vastly different results.

Imagine a node which creates line segments between points (Line.ByStartPointEndPoint). It will have two input parameters which both supply point coordinates:

Shortest List

The simplest way is to connect the inputs one-on-one until one of the streams runs dry. This is called the “Shortest List” algorithm. This is the default behavior for Dynamo nodes:

Longest List

The “Longest List” algorithm keeps connecting inputs, reusing elements, until all streams run dry:

Cross Product

Finally, the “Cross Product” method makes all possible connections:

As you can see there are different ways in which we can draw lines between these sets of points. Lacing options are found by right-clicking the center of a node and choosing the "Lacing" menu.

What's Replication?

Imagine you have a bunch of grapes. If you wanted to make grape juice, you wouldn't squeeze each grape individually - you'd put them all through the juicer at once. Replication in Dynamo works in a similar way: instead of applying an operation to one item at a time, Dynamo can apply it to an entire list in one go.

Dynamo nodes automatically recognize when they're working with lists and apply their operations across multiple elements. This means you don't have to manually loop through items - it just happens. But how does Dynamo decide how to process lists when there's more than one?

There are two main ways:

Cartesian Replication

Let's say you're in the kitchen, making fruit juices. You have a list of fruits: {apple, orange, pear} and a fixed amount of water for each juice: 1 cup. You want to make a juice with each fruit, using the same amount of water. In this case, Cartesian Replication comes into play.

In Dynamo, this means you're feeding the list of fruits into the fruit input of the Juice.Maker node, while the water input remains constant at 1 cup. The node then processes each fruit individually, combining it with the fixed amount of water. The result is:

apple juice with 1 cup of water orange juice with 1 cup of water pear juice with 1 cup of water

Each fruit is paired with the same amount of water.

Zip Replication

Zip Replication works a little differently. If you had two lists, one for fruits: {apple, orange, pear} and another for sugar amounts: {2 tbsp, 3 tbsp, 1 tbsp}, Zip Replication would combine corresponding items from each list. For example:

apple juice with 2 tablespoons of sugar orange juice with 3 tablespoons of sugar pear juice with 1 tablespoon of sugar

Each fruit is paired with it's corresponding amount of sugar.

Exercise

Download the example file by clicking on the link below.

A full list of example files can be found in the Appendix.

To demonstrate the lacing operations below, we'll use this base file to define shortest list, longest list, and cross product.

We'll change the lacing on Point.ByCoordinates, but won't change anything else about the graph above.

Shortest List

Choosing shortest list as the lacing option (also the default option), we get a basic diagonal line composed of five points. Five points is the length of the lesser list, so the shortest list lacing stops after it reaches the end of one list.

Longest List

By changing the lacing to longest list, we get a diagonal line which extends vertically. By the same method as the concept diagram, the last item in the list of 5 items will be repeated to reach the length of the longer list.

Cross Product

By changing the lacing to Cross Product, we get every combination between each list, giving us a 5x10 grid of points. This is an equivalent data structure to the cross product as shown in the concept diagram above, except our data is now a list of lists. By connecting a polycurve, we can see that each list is defined by its X-Value, giving us a row of vertical lines.

This index provides additional information on all the nodes used in this primer, as well as other components you might find useful. This is just an introduction to some of the 500 nodes available in Dynamo.

Display

Color

Watch

Input

List

Logic

Math

String

Geometry

Circle

Cuboid

Curve

Geometry Modifiers

Line

NurbsCurve

NurbsSurface

Plane

Point

Polycurve

Rectangle

Sphere

Surface

UV

Vector

CoordinateSystem

Operators

While Dynamo was originally built with Revit in mind, its versatility as a visual programming tool extends beyond Revit. Dynamo is also integrated into Civil 3D, giving users the ability to create powerful automation routines for civil infrastructure projects. It is an extremely useful tool for processing anything from common tasks to the most complex design workflows, ultimately helping you save time, optimize your designs, and make better design decisions. Dynamo offers a whole suite of nodes specifically designed for Civil 3D, as well as third-party libraries from a thriving community.

This chapter of the Primer will focus on Dynamo for Civil 3D, starting with the basics and working up to more advanced topics.