Procedural Cities with Houdini and Python

This Houdini course covers a feature film approach to procedural city generation. It takes you from start to finish, building your knowledge of Python from the ground up, from elementary to advanced examples, and many other techniques along the way.
Course info
Rating
(16)
Level
Intermediate
Updated
Aug 24, 2017
Duration
5h 4m
Table of contents
Course Overview
Introducing Python for Houdini
Preparing the Prerequisites - Part 1
Preparing the Prerequisites - Part 2
The Main Simulation - Part 1
The Main Simulation - Part 2
Creating the Skyline
Description
Course info
Rating
(16)
Level
Intermediate
Updated
Aug 24, 2017
Duration
5h 4m
Description

With expectations in VFX ever increasing, everything needs to be bigger, better, and faster than ever before. Huge environments are no exception to this trend. In this course, Procedural Cities with Houdini and Python, you will learn how to tackle the problem of generating vast CG cities, making use of Python and various Houdini techniques, while maintaining artist control every step of the way. First, you will be introduced to Python itself, and where and how it can be used in Houdini. Next, you will learn how to populate a city plan with buildings of various types, block by block, and how to automate this using Python. Finally, Python is again used to do the heavy lifting on the skyline, building a tool that ensures artist control over the height of buildings. You will use Python to import files from disk, read from and write to files, keep track of what the set-up is doing, build node networks automatically and to develop the technology required to make this city generator work internally. By the end of this course, you will output a vast, automatically generated CG city, instanced upon a point cloud containing all the necessary attributes. With this knowledge, you can go big while keeping your memory footprint as small as possible.

About the author
About the author

Timothy is currently an FX TD at Framestore, having worked as such before at MPC, Electric Theatre Collective, and as a TD at Double Negative. Before transferring to VFX he worked as an environment artist. Timothy studied digital effects at Bournemouth University and game art at the Utrecht School of Art and Technology.

Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi everyone. My name is Timothy Stam, and I'd like to welcome you to my course on Procedural Cities with Python and Houdini. I am an effects technical director at Framestore, London. CG cities are a huge part of feature film and advertising projects, whether it is in the Star Trek film series or a UEFA ad that requires an urban backdrop. Every franchise uses them in one way or another. Being able to generate them efficiently and quickly means having an edge over the competition. Houdini is one of the most important VFX tools out there. And the skills to work with Houdini are very sought after by VFX houses, big and small. Equally sought after is the ability to script with Python. A major component of this course is using Python to drive your Houdini setup. Python is one of the most widely used scripting languages globally, and Houdini has an outstanding Python API, affording you the ability to create amazing CG imagery and allowing you to couple it with any VFX pipeline. Some of the major topics covered in this course include using python to import files from disk, read from and write two files outside of Houdini, work with Python modules, building node networks automatically in Houdini, and to develop the technology required to automate the city generator system. The final result will be a vast, automatically generated CG city. And having completed the course, you will have the skills and confidence needed to develop your own Python driven Houdini setups. Preexisting knowledge of Houdini or Python would be helpful but not required before beginning the course. You will be taken through every step along the way and all key concepts and techniques will be thoroughly explained. I hope you'll join me on this journey to learn about Python and Houdini, with the procedural cities with Python and Houdini course here at Pluralsight.

Preparing the Prerequisites - Part 2
Welcome back. In this module, we will prepare the last part of our prerequisites as started in the previous module. In the previous module of preparing the prerequisites, we have broken a city plan into single city blocks. And we have imported the building using Python. Then we turned each building into a bounding box. And as a final step to that sequence, we will now create clusters of these various buildings so that we can start populating our city. Let's jump into Houdini and get started.

The Main Simulation - Part 2
Welcome back to Part Two of the Main Simulation. Here we will be expanding upon our setup from Part One. In the Main Simulation Part Two, we will be continuing where we left off earlier. We will automate our system to run an all city blocks in sequence, so you don't have to run all city blocks through manually. To do this, we will be making use of the Wedge ROP and of course Python. Python will be used among other things for writing to a file, reading back from that file, setting node parameters, filtering data by using list comprehensions, and thus in general, to drive our automation. This time we will finish up the cities entire final base point cloud. Containing all the single buildings and base sections of the stackable buildings, combine together into a seventy block city. Let's begin.

Creating the Skyline
Hi all. Welcome to the final module of this course. Previously, we created a point cloud for a city containing only unstackable buildings, and base sections of stackable buildings, and in this module, we will build the system and write the code that is going to allow us to stack them, and as such, create the skyline of our city. To do so, we will take the base point cloud we created in the previous module, and build up from that. We will build a fairly simple painting system to create height place for us. And we're going to be using that paint system and other techniques to ensure the process remains visual, and thus, artist-friendly. This, as opposed to doing everything in the code. Python will be the main ingredient in this module. We will be using a while loop to help us stack our buildings. We will make use of the techniques we've previously learned. And in the code, we're going to be using the painted values to decide how tall our building should be. We'll also make sure that our new points, the ones that are going to be stacked on top of our base points contain all the necessary attributes for the mid and top sections, in addition to the base sections for which we already have the points. These we will infer in our python code using the attributes we created before. Let's jump into Houdini and get going.