buildz

Dynamo Vasari Talk Videos Posted

noreply@blogger.com (Zach Kron) — Fri, 17 May 2013 03:12:00 +0000

In case you missed the Vasari Talk on May 15, videos are now posted:
http://wikihelp.autodesk.com/Vasari/enu/Community/Tutorials/Vasari_Talk_-_Design_and_Analysis_Webinars/Session_29%3a_What's_New_in_Dynamo

Vasari Talk: What's new in Dynamo

noreply@blogger.com (Zach Kron) — Mon, 13 May 2013 14:51:00 +0000

Where: Webinar

Date: Wednesday, May 15th,

Time: 11:30 to 12:30 pm Eastern Time

Description: In this session Autodesk's Zach Kron will discuss the latest release of Dynamo Visual Programming for Revit and Vasari. He will demonstrate the latest improvements to the user interface, new node functionalities, and walk through some of the new sample files. He will also discuss the goals of the project and how users can become a part of the development process.

Learning Objectives
After this session, participants will be able to:

Create and place sample Revit families and geometry using spreadsheet data and recursive systems.
Pattern a sample surface.
Visualize complex sample geometry quickly inside of the programming interface.
Create compact custom functionality they can share with colleagues.

Register Now!

Moving Stuff around in Dynamo: Transforms, Lists, and Making real Revit Elements

noreply@blogger.com (Zach Kron) — Mon, 06 May 2013 13:31:00 +0000

As we roll out fresh baked pieces of the emerging visual programming tool for Revit/Vasari, I thought I would walk through a couple of the new samples. Transforms (the ability to move, rotate, scale, mirror, etc stuff that you have already made) are one of the new pieces.

The above video demonstrates the process of moving "abstract" geometry around inside of Dynamo, the next video shows how to make this abstract line into full Revit geometry and still maintain the relationship to the Dynamo graph.

While we are actively improving the way that nodes handle lists in Dynamo, here is a demo of how to go from a single element to large sequences of elements using "Map" and "Combine" functionality.

Dynamo WIP Update!

noreply@blogger.com (Zach Kron) — Mon, 29 Apr 2013 15:53:00 +0000

Latest Build: version 0.3.0, released 4/29/13

It's been a while since we updated our open source project Dynamo (visual programming for Vasari and Revit), but it is worth the wait! Lots happening as we have gotten dedicated resources participating on the Work In Progress. Much of the development has been getting the underbelly of the code cleaned up and stabilized, but there has been plenty done on the "user facing" side as well.
BTW, We mean it when we say Dynamo is a "Work in Progress", and we hope that when you see things you like or hate, or could be done differently, you jump right on the issues page or the Vasari Forums and fire off your feedback. We are going to be rolling out new builds relatively quickly, so please check out the latest WIP and let us know what you think.

Download Page and Documentation
Forums
Bugs and Requests
Source Code and Development

Here's a quick tour of the improved interface and search capabilities.

Know it, Learn it

For a complete rundown of all the new features, please check out this extensive list. There are also tutorials and documentation on this site.

What's New and Updated

New and Updated Nodes:

Generally we have been working on building out the node offerings, with more basic tools (like more curves and lines, transforms, etc) but also some more sophisticated packages of functionality (like Delaunay tessellation, dynamic relaxation, and Arduino interfaces)
On of my favorite pieces is the Watch 3d node, which allows you to visualize geometry before you make it into full Revit elements. Check out the Tessellation samples for an example of this.

In the next stages, we are hoping to continue both building the basic tools (like handling lists better) as well as expand our more advanced offerings (like using external engines for analysis).

UI

Lots of basic stuff here, things that are generally thought of as "the cost of doing business" but take a little time to get done, like cut and paste, box select, etc. We also have some more exciting stuff like the ability to create custom nodes from collections of wired up nodes. This allows you to collapse large and complex workflows down into reusable and transferable custom functionality. We have also expanded the search capabilities and will be working on increasing the "browsability" of the node library.

Up next, we'd like to make it easier to not only to make your own custom nodes and workflows, but also to exchange them with other members of the community.

Engineering

It's hard to express some of this, as it involves work done in the guts of the code to make sure that it can scale, that it is easier to maintain, and that Dynamo is generally more stable. You, the user, will experience this over the coming months by steadier delivery of new builds, but also better stability and increasing quality. You, the code contributor, will see better documentation of the code, more legible source, and automated testing capabilities.

Samples

A few more examples of what you can do with Dynamo have been included. I'll be adding videos walking through their operation later this week, but in the meantime, feel free to explore the full range of sample datasets and the existing tutorials here.

Get the build now, take it for a spin, check back in for regular updates, and please, please, please give us your feedback!

Thanks!

Dynamo: free like beer, free like speech

noreply@blogger.com (Zach Kron) — Thu, 25 Apr 2013 12:25:00 +0000

Buildz has gone dark for a while, which is ironic, as I have less to hide than usual. I'm helping on the open source project Dynamo, a visual programming language for Revit and Vasari. Dynamo allows users with or without programming knowledge to create graphical "scripts" to drive BIM in complex and beautiful ways.

Usually working for Autodesk can feel like being a secret agent . . . I could tell you what I'm working on, but then I'd have to kill you. But Dynamo is a very different creature than the proprietary software that we all know and love/hate: it's free!

Reader: Free you say? No way, nothing is free.
Z: Way. Gratis+Libre. It's free like beer, free like speech.

Proof: fire up your free SharpDevelop or other development environment and go build the code yourself RIGHT NOW. Explore the latest submissions, make your own, report bugs, all that good stuff.

Of course, you will be living on the edge, building software that is piping hot out of the oven can burn your mouth. If you want to take a safer route, you can download the installer from here. Keep an eye on this site, as we are going to roll out a new installer presently, but you can get started with this "last stable" release.

Yes, I know, free is trendy. All the cool kids are doing it. But we of course have our own sinister purposes.

Staffing: There are a few geniuses working on it full time, but we need more user feedback, testing, and feature development.
Brains: You are more interesting than us, and we want your brains. You are also making stuff in this thing people call the "real world" and have the needed insight to create appropriate content RIGHT NOW. Therefore, we are hoping/relying/begging for your feedback
RIGHT NOW: we have noticed that people like to have new features, bug fixes, etc now, not later. Open development allows for faster delivery.
Community: we like people, we like to work with them. We also think that a healthy community can support itself. We believe that a community that builds and can contribute into a project can create tools that are uniquely appropriate for what they need to do.

So now, reporting to you from deep inside the belly of the beast, I can tell you it is a rich and soupy broth down here. We have some truly lovely stuff in the new code, lots more nodes, way better stability, more samples, better search and browsing, more and more. We are sewing up a couple lingering bugs, but I wanted to let you know what was in the works.

Stay tuned!

Candy Stripes for your Facade

noreply@blogger.com (Zach Kron) — Wed, 27 Feb 2013 02:15:00 +0000

User Question: I have 3 types of panels I need to alternate across my building facade in vertical strips, a full spandrel, ventilation, and vision (all glass). How do I do this without manually changing all the panels?

Try this out: manually place the three panels you want, select these, and hit repeat. The pattern will shoot across and down the whole facade. Watch the video. If you want to change elements, you can tab select the ones that are wrong and swap them out for other panels.

Base file can be downloaded from here.

Register for Vasari Talk Session 26: MIT Student Work

noreply@blogger.com (Zach Kron) — Mon, 04 Feb 2013 19:44:00 +0000

[Edit: Video from this session is now posted here.]

Tuesday, February 5, 2013 12:00 PM - 1:00 PM EST

In this session, MIT students Stefano Andreani, Aurgho Jyoti, Patrick Little, Vernelle Noel, and Jaeyual Lee from Zach Kron and Dennis Shelden's class Digital Fabrication and Construction will present case studies of Gensler's Shanghai Tower and Herzog and deMeuron’s Beijing National Stadium. They will explain how they built parametric study models using Vasari and how they then leveraged these models for additional analysis.

Export Vasari/Revit to Rhino

noreply@blogger.com (Zach Kron) — Fri, 01 Feb 2013 01:32:00 +0000

While sending data out of Rhino and into Revit is pretty commonplace, I've seen a bunch of situations where folks need to go from Revit to Rhino and run into trouble. Data is imported and doesn't show up, imported geometry is faceted, or in some way not what you're looking for.

Luckily, it doesn't have to be like this, you just need to change a couple default settings. Here's how to get a nice clean, smooth DWG into Rhino

Step 1: Solids v. Polymesh

Strangely, the default setting for DWG exports is polymesh. Assuming you want to bring in real smooth, accurate, analytic surfaces and solids, open up Export, Options, Export Setups DWG/DXF

Go to the "Solids" tab and change "exports solids as" from the default "Polymesh" to "ACIS Solids"

Step 2: DWG Versions

Every 3 years, the folks who make DWG update the file format and often times it takes a couple releases for other companies to incorporate the new file formats. If you are using Rhino 4, you will be able to import the 2007 version of DWG, if you are on Rhino 5, you can import 2010. However, the default setting in Revit 2013 and Vasari is the 2013 version, which Rhino will not accept.

So, while you are still in the export options dialog, wander over to the General tab. In the "Default export options", change the Autocad 2013 Format to 2010 or 2007 depending on what version of Rhino you are on.

Alternately, you can also change the version while you are exporting

Either way works.

3. WYSIWYG
Export is What-You-See-Is-What-You-Get. Export a Plan view and you get some funny sliced shape. Isolate or hide elements in a 3d view and you get what is on screen. Knowing this, go to a 3d view, isolate/hide what you need or don't need and Export. Import them into Rhino, and Unrollsrf, or Grasshopper, or Squish or whatever else you desire.

Thanks
Z

Vasari Talk Session 25: The Vasari Beta splash screen

noreply@blogger.com (Zach Kron) — Tue, 29 Jan 2013 01:39:00 +0000

The latest Vasari Talk (Jan 22nd) has been posted! If you missed it here’s the brief. Download the dataset from here and follow along with the video.

“Description: In this episode, Zach Kron will dive deep into Vasari geometry and show you how to model the building on our Vasari Beta 2 splash screen. He will also show you how to make some interesting and challenging geometry from past splash screens.”

Learning Objectives:

By the end of this session, attendees will be able to drive a parameter with a formula in a sample exercise.
Attendees will be able to create a parameter that is a function of another parameter.
Attendees will be able to modify the width of panels and mullions parametrically in a sample exercise.
Attendees will be able to apply parametric panels and mullions to a façade and set their parameters based on their position on the façade.

Origami and The Context Aware Panel: being a good neighbor

noreply@blogger.com (Zach Kron) — Sun, 20 Jan 2013 14:00:00 +0000

I was looking at these fantastic modular origami tesselations and thinking (as I tend to) “Vasari Panel? Sure!”

Turns out origami is hard! One of the first issues that comes up is that each panel needs to have some amount of awareness about what its neighbor is doing. In general, Revit/Vasari panels operate in isolation, each one’s behavior having very little, if anything to do with the panels that it shares edges with. For most cases, this is fine, as the creation of seamless relationships can be handled by referencing shared point normals. In this case, however, there turn out to be more than one place where geometry in PanelA needs to reference the same geometry as PanelB.

The kernel of this solution is a 9 point adaptive component that is repeated 4 different times over a surface. The center of a 9 bay grid defines the center of any given panel, and the remaining 8 reference the centers of all neighbors.

With this solution in mind, let’s take a look at our origami pattern

If you break the pattern down into repeated elements, at first you can do the standard thing of identifying a rectangular set of points.

Here I am identifying the low point of each module and just connecting the dots.

That module is built on a “seamless panel base”, where I just look at where are the lines intersect with an imagined cubic space projected off the surface of the form, and connect the dots.

Q.E.D., right? Now we can all go back to doing important work, please?

NO! This solution leaves out an important piece of information

Look carefully at the resulting pattern, and you will see a kink in what should be a straight line connection between the high points of the modules!

Each panel piece needs to REACH OVER into the neighboring panel and make a straight line connection between interior geometry in itself and interior geometry in the neighbor!

A minor detail? No! This simplicity is what lends clarity and readability to the pattern.

In a completely flat, regular system, this would be no problem, as there would be no kink.

But with irregular curvature, where angles are changing, you can’t pre-calculate where that reach-over is going to need to land.

What’s a girl to do?

If you conceive of each high, square area as the center of each module, each panel needs to know about 4 other similar centers:

But with this configuration of 5 points, you can’t determine the extents of each cell. For that you also need to get the geometry of the centers of the remaining 4 corner neighbors.

Therefore, for every one cell that gets placed, it must have one point to identify its center, and 8 to identify its neighbor’s placements.

So you have a 9 point adaptive component where point #5 represents the center of one square we will model, and the remaining 8 points represent the neighboring cell centers

If you connect #5 diagonally to the corner neighbors, you can derive the lines out from the center that will define the lowest points of the pattern.

Imagine that points 2, 4, 6, and 8 will similarly be the center of their own high, square areas and connect them

Host points at he intersections and you will have the corners of the lowest points of the pattern.

These corners are where the panel will connect at the lowest point with its neighbor

Ok, head hurting? Hang on, it gets worse. This is a fully 3 dimensional pattern, that offsets from an arbitrarily curving surface. So we need to attack the Z-direction by placing points on the horizontal workplane of each adaptive point and offsetting the desired thickness.

Connect the diagonals again and we can define the high, square area.

Now we connect more dots to create the folds:

One last piece. We place 4 of these little monsters on our divided surface, overlapping so that each block of 9 control points relates to its neighbor. Note that there are multiple areas of alignment in 3 dimensions of neighboring panels.

Select each of the 4 families, one at a time, and hit the Repeat button:

This will result in 4 different Repeater elements on the surface.

Tada!

There are still 3 missing features that are not solved with this. 1. Edges only match up on surfaces that have planar panels: revolves, translation, single curvature, and flat surfaces. Paper will stretch, crinkle and bend a little, mine doesn’t. 2. The high, square areas do not rotate, that is, they stay in a gridded orthogonal relationship to each other. In the actual origami example, they rotate against each other. 3. Perhaps more interestingly, there is no necessity for the panel elements to remain dimensionally static while only changing their angular relationship. I think there is some interesting math to be done that might solve this last problem, and I can approximate it with some formulas that adjust the height of the family with changes in size of the cell, but it isn’t perfect.

(animation made with BoostYourBIM’s Image-O-Matic and Gimp)

Download the family from here. ContextPanel_seamless.rfa is a base family that can be used to make your own patterns that need to reference neighbors. ContextPanel_hosted has the origami panel module hosted 4 times on a surface. Select each one and Repeat for each to cover the surface.

Suggestions for improvements or totally alternate approaches welcome!

BoostYourBIM Contest and Prizes!

noreply@blogger.com (Zach Kron) — Fri, 18 Jan 2013 18:56:00 +0000

Do you want Harry the Revit API Guru to build you your very own custom Revit plug-in? Now is your chance! BoostYourBIM is offering a free custom API addin to the person who makes the best use of his brand new Image-O-Matic addin for Revit and Vasari.

Ok, that’s a lot of words. Let’s break it down

BoostYourBIM: blog written by one of the developers of the Revit API. So, he has the chops.

Image-O-Matic: an addin in for Revit or Vasari that will automatically write a sequence of numbers to a specified parameter or iterate through phases, dumping images as it goes. Do a little post processing and you can animate your BIM!

Custom API addin: this is the hard part to define, but it may be up to you to decide what it is. Always wanted to place walls in the configuration of a Mandelbrot set? Or dump all your curtain panel data to a spreadsheet in just the right way? Fire up your mad skillz and win this contest!

Read the contest rules here, and Good luck.

Space Frame Quickie

noreply@blogger.com (Zach Kron) — Wed, 02 Jan 2013 03:17:00 +0000

I did a post way back in ancient history about a space frame, and a few questions have come in on how to put it together.

Space Frame Quickie

Download the source file from here.

Paper Models, II

noreply@blogger.com (Zach Kron) — Thu, 20 Dec 2012 14:32:00 +0000

Because she is awesome, my wife got me an awesome birthday present: an E-Craft electronic die cutting machine. The target application of this tool is scrap booking, and the machine’s marketing boasts that it can cut sheet magnets and glitter paper, AND it comes in pink and periwinkle blue. None of these features seem to scream Architecture, Engineering, or Construction. Our (AEC) people seem to favor the white, the black, tiny glasses, and bowties. And NO GLITTER.

Our people are, of course, no fun.

So what IS an electronic die cutting machine? Similar to a pen plotter with a knife blade, I’m using it like a poor man’s laser cutter. You feed it an SVG file, and it will cut whatever the hell it is, out of whatever you feed in the front (thin stuff, within limits). You certainly can’t build ANYTHING, it isn’t a 3d printer. But it’s actually more interesting, IMHO, because it forces you to build certain KINDS of geometry. Stuff that can be folded, bent, creased perforated, poked, scored, and cut out of flat material.

(Hmm . . . does that sound like a reasonable limitation for lots of kinds of architectural construction?)

For today’s exercise, I will construct Sir Norman Foster’s toroidal masterpiece, the Copenhagen Zoo Elephant House. Because the universe demands symmetry, I will cut it out of a donut box.

The workflow to get the cut pieces involves Vasari (or Revit, which needs the STL Exporter addin), the open source vector art editor Inkscape (and a plugin extension from Evil Mad Scientist’s Eggbot), the papercraft application Pepakura, and a papercutter (this can be scissors, a lasercutter, an intern, or the Ecraft tool I’m using.) Pepakura will run you 38 bucks (totally worth it), the rest are free.

Step 1: Rational Forms in Vasari/Revit

While there are some more exotic methods to create flattenable forms (see this, and this), I’ll start with the method Sir Norman often uses of dicing up rational primitives. For the details on this process, check out this post.

Step 2: Panelization in Vasari/Revit

Once the surface has been divide, populate the divided surface with a simple surface. That is, make a new curtain panel with just one surface and load it in.

More details on this part can be found here.

Step 3: Export to Pepakura and Unfold

Once I have my panelized form, I isolate the pieces I want (either using temporary hide/isolate or visibility graphics) and export using STL export (either native to Vasari in the add-ins tab, or as a plug in for Revit). For this kind of form, I like to also send out the “floor” of the form even if I’m only interested in the roof, as it helps keep the roof shell from spreading out.

Import the file into Pepakura

Again, more details on this process can be found here.

Once I get the panels into Pepakura, I just hit “unfold” and get the geometry needed for cutting. There are lots of little bitty edge pieces that I just throw out, but otherwise, I’m good to go. For this kind of form, I also like to turn OFF the default behavior to make “tabs” as they just get in the way.

Step 4: Convert to Ecraft file in Inkscape

My cutting machine only takes SVG files, and Pepakura doesn’t make ‘em, so I need to do some data wrangling. I output to EMF, which is a vector format, and open it up in the open source vector art editor Inkscape.

While I’m in Inkscape, I like to use the a little tool provided by Evil Mad Scientist for their Eggbot printer called Reorder Paths for Speed. What this little delight does is take your jumble of lines and puts them in order using a traveling salesman algorithm. If you don’t use this, your cutter will jump all over the place drawing lines in the order they were created. Using this plug in makes the cut time way more efficient.

(If your shape is relatively simple, and you have Autocad, you can use the “boundary” command to recreate the shape, which has the result of making the cutting process continuous rather than skipping around. But as far as I know, Autocad doesn’t make SVG files)

Step 5: Cut and Fold

Now we are ready to save to an SVG file and import into the E-craft software.

The capabilities of this layout tool are pretty limited, so you really need to be ready to go before importing your SVG.

Before printing, I need to trim up my donut box a bit

And we’re off!

Pop out the pieces

Assemble with many little pieces of tape

Make it out of watercolor paper instead of a donut box and you can bring it to a client meeting! I have found frozen pizza boxes to be one of the most reliable materials.

This description was fast and dirty, so apologies if run into any snags on the the way. As with any toolset, each one has its own personality and quirks. Pepakura and Inkscape are both really powerful and interesting in their own right and deserve deep investigation. The Ecraft is a crazy machine that is often as frustrating as it is excellent. Maybe I’ll do a post on how I MacGyvered the thing to use real pens.

API-Yi-Yi: Boost Your BIM

noreply@blogger.com (Zach Kron) — Wed, 19 Dec 2012 22:21:00 +0000

For all y’all out there looking for more information on expanding your out-of-the-box Revit experience, there is a new blog with tips and tricks for using the API.

Boostyourbim was started up less than a month ago by my friend Harry Mattison, who brought you such greats as the parametervalues from image data addin. So why should you rely on him for information on the Revit API? He helped build it!

Pattern Deformation

noreply@blogger.com (Zach Kron) — Mon, 17 Dec 2012 15:58:00 +0000

A big shout out and thanks to the folks at DesignCoding, “a digital diary of research on the relationship between basics of geometry and design computing”. They’ve always got nice stuff going on with that site. I was looking at their post on Parquet deformations and had the familiar “oh yeah! Lemme try THAT!” response

As with many things that look complex and awesome, the underlying logic is pretty simple. Here we start with a regular square grid of a divided surface.

Onto it I place a 5 point adaptive component that is structured like the image below:

With a model line between points 2 and 4, and another line between 5 and the midpoint of 2,4. A reporting parameter between 1 and 2 drives the point p1 hosted on the line between 5 and midpoint 2,4.

Four placement points are hosted on the nodes (2, 3, 4, and5), and another goes on a point off to the side, hosted on a free point. This point (1) serves to tell the family how far it is from a starting point

Using a reactor type of behavior, as the point 1 gets further and further away, it drives p1 in the family.

This basic idea can then be amplified with a slightly different AC, placed in a sub pattern:

This family is placed four times, in a radial arrangement, with point 2 at the middle.

Repeating this block of 4 components results in 4 separate Repeaters, which resolve into this pattern:

Pattern Deformation

Download the files from here

Tool Making: Way better Bezier-ish by Points

noreply@blogger.com (Zach Kron) — Sat, 08 Dec 2012 16:00:00 +0000

As previously discussed, Revit/Vasari has a couple kinds of splines (regular spline and spline-by-points) that you’d think they were pretty similar (but you’d be wrong). I made some tools to improve on this situation using Adaptive Components, but have refined this method. This image shows 3, 4, and 5 point spline-by-point curves inside of an adaptive component rig, superimposed on a regular control polygon spline to illustrate the divergence (There’s not much difference, but double click to take a closer look).
It uses the same methods as shown in this post but does further subdivisions of the control polygons for greater accuracy and flexibility.

A couple of things I noticed. Most significant, the tangency conditions at the start and end are very close approximations. 99 times out of 100, this should be fine. Here is an example of when it falls down:
On the left, two real b-splines drawn coming to tangency conditions. On the right, the 4 point adaptive component spline by point family.

Because the curves come together into a near tangent, but not quite, they slightly overlap. It isn’t visible even zoomed WAY in.

But the result is that you can’t create a form element from the fake b-splines, because it will create a self intersecting form, but the real b-splines can.

[Clarification: This failure is kind of hard to reproduce, it doesn’t happen for all situations even like the one shown, there is a similar geometry in the sample files, and it works perfectly. I think it has to be of a particular really huge scale. In general, you can use this to make forms just fine, as shown in this post. Here is an exaggerated view of what is happening the joint between the 2 curves at a bazillion times magnification:

Again, I have a hard time reproducing this problem, but it can be done. If you’re worried about it, experiment a little. ]

The other issue that is a bit more obscure, is the four point 4 spline doesn’t create a proper cusp when you do a crossed rectangle (shown here, a rectangle with points going 1, 3,2,4 in clockwise order) as a real bezier does. Rather, it makes a bump.

Details, details.

Download the families from here.

Autodesk University 2012

noreply@blogger.com (Zach Kron) — Sun, 25 Nov 2012 13:35:00 +0000

November has been hectic, but I promise I will be back in December with more advice on things you didn’t know you were interested in.

In the meantime, if you are in Las Vegas this week, I’ll be co-presenting a couple sessions at AU.

AB3910-L - Coding Autodesk® Vasari: Scripting for Conceptual Design

Nathan Miller , CASE Inc
Zach Kron , Autodesk
Matt Jezyk , Autodesk, Inc.

This hands-on lab will introduce participants to the fundamentals of Python scripting and visual programming within the Autodesk Vasari conceptual design environment. Custom code gives users the ability to efficiently automate many design tasks while also enabling new generative design capabilities. This lab will demonstrate how to compose useful Python scripts with the RevitPythonShell add-in and Dynamo Visual Programming for Autodesk® Revit® software and Autodesk Vasari. The lab will provide users with resources and step-by-step examples for automating geometry creation, adjusting family parameters using external data, and sharing information with different design platforms.

Additional Information
Wednesday, Nov 28, 8:00 AM - 9:30 AM– Mandalay Bay H, Level 2
Key Learning Objective 1: Explain the basics of Python scripting in the Autodesk Vasari design environment
Key Learning Objective 2: Automate conceptual form creation
Key Learning Objective 3: Drive family parameters programmatically
Key Learning Objective 4: Take advantage of external data to create geometry and drive parameters
Professional Credit:AIA Approved
Class Type:Hands-on Lab
Class Length:1h 30m

AB2410 - Echo Chamber: Complex Parametric Arrays in Autodesk® Revit®

Andreas Dieckmann , RWTH Aachen University
Zach Kron , Autodesk

To a large extent, buildings consist of repetitions of identical or sufficiently similar elements. In its previous versions, Autodesk Revit software already included a number of tools that allow for repeating elements, albeit with some geometric or category-specific limitations, such as arrays, divided surfaces. The new Divide & Repeat workflow of Autodesk Revit 2013 offers a more open and versatile functionality that can be used in a host of different contexts. This class discusses various patterns for creating Divide & Repeat rigs consisting of a combination of reference points, divided paths, and divided surfaces. We will take a detailed look at each pattern and its practical application in architectural design by examining examples of iconic buildings and identifying how certain aspects of those buildings could be created with the Divide & Repeat functionality. The class also touches on the methodological implications of creating rigs and components for the discussed patterns.

Additional Information

Tuesday, Nov 27, 3:30 PM - 5:00 PM– Palm D, Level 3
Key Learning Objective 1: Identify repetition strategies based on design intent
Key Learning Objective 2: Devise rigs for Divide & Repeat based on repetition strategy
Key Learning Objective 3: Devise repeater components based on repetition strategy
Key Learning Objective 4: Explain repetition in the context of case studies of iconic existing buildings
Professional Credit:AIA Approved
Class Type:Lecture
Class Length:1h 30m

Happy Halloween IV

noreply@blogger.com (Zach Kron) — Thu, 01 Nov 2012 04:07:00 +0000

[John Fout’s pumpkin attacking a coworker’s structure]

Good evening, and welcome to the 4th Annual Parametric Pumpkin Carving! In some cultures, the number four is bad luck, as it sounds like the word for DEATH. Tetraphobia, as it is called, is entirely appropriate tonight, as you will see . . .

Behold! [and download]

The assembled might of multiple digital media! Their powers magnified and catalyzed by the churning, chaotic cauldron of All Hallows Eve!

Look upon them, dear readers . . . if you dare . . .

Baddest: Ritchie Jackson

Following in the tradition of badasses, base jumpers, Baumgartners, and Nikola Tesla, “Bad” in this case is regarded as high praise for an uncanny scariness, a serious and terrifying aspect.

First time Parametric Pumpkin winner Ritchie Jackson was not satisfied with taking home the gold last year for Mostest Parametric. In fact, it whipped him into a fighting fury. He established an island lair in the mid-Atlantic, whence he was able to monitor and brood, creating the Honourable Society of Cucurbita Carvers and building the ultimate weapon of pumpkin distribution, the Fabrica Cucurbita.

That, I would assert, clinches a person’s right to the title of Pumpkin Badass. But keep in mind that it is done, as many badass enterprises are, for the good of the community.

Now, you too, dear reader, can experience the raw Power of the Pumpkin with Fabrica Cucurbita, a first person shooter, immersive pumpkin gaming experience. Just download and uncompress the zip file, fire up the exe and you’re off defending the cause of pumpkin carvers everywhere.

“All the geometry was done in that king of 3d apps - Sketchup (free version) - but don't tell anyone as it will ruin my reputation. Come to think of it, working on pumpkins has probably damaged my reputation anyway so go ahead, let the Revit/Vasari maestros have a hearty laugh at my expense!”

[See!?!? Total badass. Just throw a “Mwahahahaha!” in there.]

“Whilst none of the geometry has been generated by code there is a lot of scripting behind the scenes for the various interactions and the graphics for the scanner particles and electrical arcs on the pumpkin gun.”

“But wait” you, the reader, say. “You haven’t even shown any of Ritchie’s pumpkins!” True. I’ve already given too much away, the beauty of games is in the manner in which they reveal themselves. Suffice to say, Ritchie has a badass cannon, and he’s not afraid to let you borrow it. Download it, use it. Heck, be a badass yourself and try it out during that conference call you have later today.

The Goodest: Andy Milburn

The pumpkin that gets to the wholesome essence of both Jack O' Lanterns and the design platform on which it was built. Free of workarounds and hacks, this winner is a model of both creativity and good citizenship.

Like Steve Martin, Frank Zappa, and Bertolt Brecht, Andy Milburn finds the profound aspects of life in small, comic, and ridiculous things. For this I am grateful, and I’m not kidding.

Our second repeat winner this year, Andy has set up a bit of an artisanal digital fruits and vegetables green grocers shop out in the deserts of the UAE. You may have already seen some of his work, as he has been developing this masterpiece of parametric vegetation for the last 2 weeks, out in the open, at Shades of Grey.

It’s difficult to summarize what Andy has done. Like last year, he has taken the idea of making digital pumpkins to a whole new level. Exploring issues of proportion, pattern, color, composition, and more. Andy draws inspiration not only from the pumpkin, but Disney, Habsburgian painters, and basically the entire vegetable kingdom.

Seeing Andy at work is humbling. Last year, when I started reading the 6 part epic, I was struck by how beautifully he had captured the idea that, in this somewhat frivolous exercise of carving, there was the kernel of ideas that are so large and profound. This year, he built on top of the somewhat abstract ideas, and actual demonstrates how to put them into formal expression, over and over again with various challenging shapes

There are so many lessons and wrinkles in the story leading to these images and files, that I insist that you go and read all 9 posts right now. Then, Andy is going to give a little walk through on Vasari Talk next week. You can and should register to get in on this talk from here. Space is limited, so do it now, takes a minute and costs nothing.

Mostest Parametric: David Wood

The pumpkin that is shaped by rules and variables, that is definite yet infinitely flexible. It not only defines a particular look and feel, but conveys the possibility of endless variation.

This award is always a little tricky, as it is not necessarily concerned with what a pumpkin is, but what it could be. David Wood submitted a very humble piece of geometry (above) and a Dynamo definition for it:

From this, was able to make these shapes by adjusting the parameters:

In David’s words

“I based it on Johan Gielis’ Superformula of an ellipse, from his 2003 paper, with the parameters set to generate a sort-of pumpkiny shape. You could tweak the parameters to create all manner of non-pumpkiny shapes if that was your thing.

Anyhow, other than the fact that it’s very slow; and very fragile; and only runs in debug mode (so far); and that if you change certain parameters, it breaks the loft, the Dynamo diagrams do eventually pull together to make parametric pumpkins! A triumph.

How it works:

The core is the ‘Superformula’ node, which calculates one value. This is used by the ‘Superformula XYZ’ node to generate an XYZ, and then the ‘Superformula Loop’ node generates a loop of lines.

The ‘Superformula Loop Driver 2’ node generates a loop at a particular polar coordinate, so that the main workspace ‘Revitator’s Punkinator’ can generate a series of loops like horizontal slices through the pumpkin.

There are a bunch of other helper nodes like the x^y node, that fill in specific functionalities in Dynamo. I believe that I’ve included them all in the zip, but shout if there are any missing.

I’ll post some more detailed explanations & screenshots on the blog over the next week or so.”

A couple other things of note. I found that it only runs on a Revit installation of Dynamo, not Vasari, and it gets slower the more you play with it. Yay Alpha software!

Please keep an eye on David’s Revitator blog, great things are coming.

Special shout outs and appreciations

John Fout

John had a kickass pumpkin this year. Here it is eating a structural system.

And in full tendrally attack mode.

John Fout’s Attack Pumpkin

It kills me, John, but your badass veggie was up against a first person shooter game this year.

Kelvin Tam

Kelvin’s wicked Pumpkiron Man has various curvaceous sliders that can create some great variations. He also demonstrates some tricks with loaded profiles that I had no idea about.

“What I have done is nesting a profile family into a new family, make points exactly at the same locations of the points in the nested family, select the points and do splines. In this way when the secondary profile family is loaded, all the model lines are picked altogether since they are no other reference lines from that family.”

Might seem a little obscure, but this method opens up a lot of possibilities for using loaded profiles. For more on this kind of work, read this.

Paul Aubin

Paul took his existing research with classical columns and plugged pumpkins into the proportional systems.

Voila! New wine in old wineskins!

Alfredo Medina

Alfredo’s haunted pumpkins have excellent spring

Try them out with the Sliders plugin.

Scott Dietz

Scott had a late arriving set of images that are tantalizing!

Send in those rfa files! I’m very curious about how this was put together.

------------------------------------------------------

I am out of time, but thank you thank you thank you all who sent in the wonderful, fantastical and ridiculous pumpkins.

And apologies for the overheated prose. My son and I have been reading a LOT of 80s era comics . . . they were not only more vavavoomy back then, but also surprisingly chatty.

Pumpkastention

noreply@blogger.com (Zach Kron) — Sun, 28 Oct 2012 13:34:00 +0000

The team at Buildz is extending the deadline for pumpkin submissions! Please submit before we peel open our sleepy eyes at 7am Monday Morning, eastern standard, Oct 29!

Thanks!

1 Day to Pumpkin!!

noreply@blogger.com (Zach Kron) — Sat, 27 Oct 2012 16:17:00 +0000

Do it now!

2 days to PUMPKIN!!!!

noreply@blogger.com (Zach Kron) — Fri, 26 Oct 2012 14:02:00 +0000

[Top of Scott Davis’s 2011 submission]

A few early entries has come in, and they are lonely! See! They would like some company. Cancel your Friday night plans.

Details on submission here. Send images, files, video’s, whatever it is that gets the idea across.

I will now jump in a leaf pile.

Make Your Own Tools: 2 pick Arches

noreply@blogger.com (Zach Kron) — Tue, 23 Oct 2012 19:25:00 +0000

Some students have been scratching their heads about how to get their parametric arches working. The arches need to be defined by start and endpoints, and the height will flow from some formula driven by the length between start and end. Here are 3 families showing 2 ways to get a parabolic arch and 1 way to get an arc segment.

Make Your Own Tools: 2 pick Arches

Download the families from here.

For further reference on a little bit of math that I’m using, check out this resource.

6 Days to Pumpkin

noreply@blogger.com (Zach Kron) — Mon, 22 Oct 2012 18:52:00 +0000

[John Fout’s 2010 Mudbox submission]

6 days to make a pumpkin! That’s loads of time, so get to it! Plant the seeds, water it, sprinkle it with 00010100100100101’s, and send it in.

4th Annual Parametric Pumpkin Carving FAQ:

I made my pumpkin out of real pumpkin, can I still submit it? Yes, absolutely, but please take pictures, don’t send in original perishable items. The Buildz hollowed out volcano lair begins to smell a bit funky.

I try and adjust my pumpkin’s parameters, but nothing (interesting) happens. Why? This is common, and happens to lots of people’s pumpkins. You might be trying too hard. Try taking a hot bath, or a little wine and some candles, then try again.

My pumpkin is almost ready, but I could use some help. Can I send in a question? Yes, no guarantee that I can answer it, but will try. Remember: there are no stupid questions, only stupid people who don’t ask questions.

I think my pumpkin might actually be a gourd? That is not actually a question, but a statement with a high pitched ending to make it sound like a question. It makes you sound cheap and ditzy. And you should support your gourd/questioning pumpkin in whatever lifestyle choices it feels comfortable with.

More FAQ.

Gaudian Columns

noreply@blogger.com (Zach Kron) — Wed, 17 Oct 2012 13:37:00 +0000

I’ve been reading Mark Burry’s excellent Scripting Cultures: Architectural and Design Programming, and there’s a nice discussion of recreating Gaudi’s design intent for the Passion Façade narthex of the Sagrada Familia Church. One feature is a column created by combining a hyperbaloid of revolution with a series of hyperbolic parabaloids. That is to say, there is a tilted nuclear reactor column shape

that is expanded on the top and bottom with saddle shapes.

As with most of Gaudi’s later stuff, one of the very cool things is that these forms are well understood in terms of fabrication, as they are ruled surfaces. It also means you can also think of them pretty cleanly in terms of guidelines and resultant form. Nice for parametric modeling!

For my Revit model, I started with an adaptive component with 2 adaptive points with circles hosted on their “normal” workplanes. These will define the top and bottom and convey the tilt of the host plane. ( This is a little different from Mark Burry’s study, as he is tilting the column and then slicing it off, which makes a very different form, but I may try that method another time.)

The circle is actually 2 semi-circles, and they are hosted on a reference line that is hosted on the normal plane of the point. This allows me to create a rotational parameter to crank the top and bottom. From this I can make my basic hyperbola of revolution

Next I need to create points on the column that will host 3 of the 4 points for each of my saddle shapes.

I host 4 points on the 2 circles , each one paired with the parameters of a counterpart on the other circle.

This allows me to connect the dots and instantiate straight line connections that precisely follow the ruled surface. I can also derive the point of intersection of these 2 lines on the surface.

To create my saddle shape, I need 2 skew lines that each start at the edges of the column, and one ends along one of the ruled lines of the column, and the other lies on my hosting surface.

When I select these 2 lines and hit Create Form, I get this nice saddle shape

Which also precisely corresponds with the surface of the column.

(Unfortunately it is just a surface, I need to go back and look at strategies to make it a solid.)

After making this twice (Gaudi’s does this 4 times, on top and bottom) and adding some parameters to establish some basic proportions, I can go to bananas and just start placing it on stuff in a host element. They need to be vertically aligned along the axis of the fins for the tangencies to work out, but otherwise, it’s good to go.

So, there is a lot more to what is going on in the Narthex (isn’t that fun to say? Narthex, narthex narthex), and the family I made has some more tricks buried in it, but I think this shows a couple of interesting principles. Download the adaptive component from here.

Intro to Repeat, Intersects and Adaptive Components

noreply@blogger.com (Zach Kron) — Mon, 15 Oct 2012 21:32:00 +0000

Here is a minimally edited recording of a class I did this morning for Dennis Shelden’s Digital Fabrication and Construction class at MIT. Starting from new template files, we create nested building masses to isolate building form from component elements, create an abstracted double skin façade condition, and make components that establish relationships between interior and exterior skins. This builds on a basic understanding of form element creation and divided surface creation (sorry, the recording from that class failed).

Intro to Repeat, Intersects and Adaptive Components

You can download the stepped datasets here.