One often heard argument is that 30, 50 or 60 fps are a bane of video and diminishes production value. Stu argues that audiences have rejected shows shot at such framerates. I think the argument falls short and there is much more to it than framerate. Shooting on video is the main culprit. Video has much less dynamic range than chemical film (only recent developments rectify that). Also, the 180° shutter in film cameras has a very specific optical quality (due to the mechanical workings and the 1/48 sec exposure). Video with their CCDs and CMOS chips often has been exposed at 360° thus exhibiting a very different quality in motion blur. Furthermore CCDs (the predominant form of sensors for a long time in the video world) are read line by line – resulting again in a very distinctive look due to the temporal shift from the top to the bottom of the frame. Video also more often than not is shot interlaced as that is the format which is broadcasted. All that contributes to the “video look”. Framerate is just one aspect – though still an very important one.

I think we agree that film is becoming a rare beast in production and the shift to digital is almost complete. So we already witness a change in optical shutter quality (a rotating disc versus digital sensor readouts). While a film camera would not be able to expose at more than 180° our new digital cameras can. Still, almost every DOP (director of photography) would pay attention to follow the 180° shutter rule to keep the film look and we all should be thankful for that. Opening the shutter for more than 180° would increase the motion blur. This would mash up the picture tremendously. So we end up in the digital world shooting “film” that very closely looks like what we have been used to for many decades.

By wanting to keep the film look the framerate is also kept at 24 fps. Quite understandably so. Though with that decision (or lack of decision to change it) come all the shortcomings of film. Fast pans can start to judder or strobe. The same is true for fast motion. Still, most DOPs and directors have not thought about using different frame rates. Quite understandably so as it would result in a very different look, would it not?

That’s the point where I think Peter Jackson really made a smart move.  He is shooting at 48 fps – double the framerate. This might sound insignificant and I’ve heard arguments why not 50 fps like with PAL or 60 fps like with NTSC. I argue that 48 fps have a dramatic consequence over those frame rates considering a second aspect: shutter angle.

Filming at 48 fps with a 360° shutter will give you a frame that is indistinguishable from a simultaneously shot frame at 24 fps with a 180° shutter. Both frames have an exposure of 1/48 second. Both sensors will have the same amount of light hitting them. Both frames will exhibit the same amount of motion blur. On a frame-by-frame basis they will be identical. The only difference – which still might be considerable – is this: shot at 24 fps you blank for 1/48 second every frame. You essentially miss half of what is happening. At 48 fps you fill in those 50% of missing time. You get the whole picture, so to speak.

Also, think about this: In cinemas film has been projected with shutter rates of 48 or even 72 Hz to reduce flicker for a long time. So what has been recorded at 24 fps has been projected at 48 fps for good measure. Film has been mangled through a 3:2 pulldown (NTSC) or sped up by 4% (PAL) for DVD and TV release and shown at 50 or 60 interlaced frames. Still, movies have retained the “film look” after all that torture. Yes, it still has been recorded at 24 fps at 1/48 exposure. I argue that recording at 48 fps at 1/48 exposure will retain the film look and getting rid of judder and strobing which should come at great relief -especially when projected in stereoscopic 3D.

Just one note: I don’t know what shutter angles Peter Jackson is using on The Hobbit. Somehow I have the gut feeling that a 360° shutter would be a logical choice to make regarding lighting requirements, motion blur quality, speed of lenses etc. … Just saying

Update April 26th, 2011: Peter Jackson posted on Facebook that they are shooting at 48 fps with a 270° shutter (translating to a 135° shutter at 24 fps). So it’s right between the traditional 180° and my speculation of 360°. Smaller shutter angles have been used before on film @24 fps as well (giving that very crisp, strobing look). I for once am curious how The Hobbit will look.

Usually, we want a script to do something with the objects we have in a scene. So the first step is to look at how we can access the scene file and go through selected objects and perform Cinema 4D commands on them.

Accessing the Cinema 4D Scene

Let’s start with the basics. We import the c4d module and check if we are running as a script within Cinema 4D (remember: __name__ is defined as “__main__” in this case, so we check for that value):

The pass statement does nothing. We use it as placeholder for code we will now place inside the if block. Without it, Python would complain as it expects a statement within if.

When looking through the Cinema 4D Python documentation we find the c4d.documents module that has all the functionality to access our scene. The function GetActiveDocument() function returns the currently active scene as a BaseDocument object.

Now that we know how to access the scene we are left with finding out how to get a list of the selected objects in the scene. Looking at BaseDocument we see that it has a GetActiveObjects() method that returns a list of BaseObject objects.

Now let us implement this:

So far so good. We fetched the scene using GetActiveDocument() and assigned it to the variable doc so we can reference it later when needed. Then we stored the list of selected objects in the variable selected (NB: other than in the documentation, GetActiveObjects() requires a parameter. 0 works fine for me so I use that).

Now here is something new. What is a list in Python?

Python Lists

Python lists are very versatile and are really powerful and actually easy to use (at least compared to other programming languages like C++). I won’t go into much detail on lists here for now. Read up on the Python documentation if you want to learn more about them. For now it is sufficient to learn that lists contain several objects. We can access them through an index like a = list[2]. This would access the third object in the list as they start at index 0 (zero).

For our script we would need to know if there is an object in the list, ie. if there have been objects selected. Python has a build-in function to see how many items a list contains: len(). So len(list) returns the number of objects in the list. Very convenient! So we check if there are objects n the list and then we “go through” them and do “something”.

Traversing Selected Objects

The question is, how do we “go through” the list? This also is quite easy in Python. Say hello to the for statement: Python’s for statement iterates over the items of a sequence (like a list or string). in the order they appear.

This will “go through” all items in the selected list. Within the for statement we can access the individual item through the ob variable we used in the for statement.

So we make something simple and let our script output all the selected objects’ names to the Python console as a test:

Now we are getting somewhere!

Collapse Extrude Nurbs Script

Over at the CG Society forum there was a request for a script that collapses Extrude Nurbs to polygon objects. Let us use this as an example.

So what do we want the script to do?

1. Go through all selected objects
2. Check if it is an Extrude Nurbs object
3. Make it a single polygon object

Sound simple enough for a start without being too simple and without purpose.

We already nailed the first step: Go through all selected objects. Done

Checking for an Object Type

So how do we check if it is an Extrude Nurbs object? We could check for the name. By default Cinema 4D calls them “Extrude NURBS”. Doing that would quickly fail though as users can change the name. Looking at the BaseObject class that represents all objects in a Cinema 4D scene we don’t find much useful though.

Now here is a “tricky” thing with classes: They inherit the properties of their ancestors. Looking at the c4d module documentation we see that BaseObject is a descendant of BaseList2D which is a descendant of GeListNode which again is a descendant of C4DAtom. Looking through all those classes we see that C4DAtom has a method GetType() which returns a number containing the type ID of the object. Looking further we discover that BaseList2D has a method of GetTypeName(). We can use either to check if the object is an Extrude Nurbs.

As we do not know the type ID or the type name of an Extrude Nurbs we can use our basic script to give us those values.

Printing the object’s name, type name and type ID to the Python console will show us the values we need for our script. Using a comma (,) after the last object with the print statement will prevent a new line so the output for each object is on one line.

The output should be something like this:

Sphere is an <Sphere> ID: 5160
Extrude NURBS is an <Extrude NURBS> ID: 5116
Cube is an <Cube> ID: 5159

So now that we know both the type name (within the angle <> brackets) and ID for an Extrude Nurbs. By creating an object, selecting it and running the script above we now can determine the values for type ID and type name of any object.

Using these values we can check if objects are of a certain kind:

Step 2 – check if it is an Extrude Nurbs – done!

Performing Commands on Objects in a Python Script

Now that we can traverse the selected objects in a scene and know when we encounter an object of a specific type (in our case a Extrude Nurbs) we need to perform some action on them. In this example we want to convert the Extrude Nurbs in a polygon object and have the front and back cap connected with the body (by default, the caps are disconnect from the extruded polygons).

At first, we see what steps would be involved when doing it manually:

1. select the object
2. perform “Make Editable”
3. select all created children
4. connect the objects and delete the originals
5. use “optimize” to connect the caps to the body

To perform these steps we could write the instructions one after the other within the if-statement. This would result in ugly “spaghetti-code” though and we could use the code we have so far for other purposes as well. Last time we saw how a function is defined in Python so we will make use of that and put the code that performs all the above steps into a function.

This is the body of our function. We give it the name MakeExtrudeEditable. We define two parameters that we pass from the outside. A reference to the current scene (doc) and a reference to the object we want to convert to a polygon object (op). pass is a placeholder for now that does nothing but Python requires a statement within the function.

The whole script looks like this:

We need to define our function before the main code so that it is known to Python once we call it from there. Instead of the print-statement from before we now call our own function within the inner most if-statement once we are sure the object is an Extrude Nurbs.

Now for the action. As the list of selected objects might contain several objects we need to make sure the object in question is the only one selected. So we need to select the object. The BaseDocument class provides a method called SetActiveObject that has two parameters: the object and the mode. By default the mode is set to SELECTION_NEW which sets the selection to the object used as first parameter. An existing selection will be gone. That’s exactly what we want. So we call the method using the default parameter, ie. we omit the second parameter mode.

To perform a command that is called from a menu or icon in Cinema 4D the c4d module provides the CallCommand() function. It expects an ID that represents the command. To find out that ID we need to open the Command Manager in Cinema 4D. Using the name filter we can search for the “Make Editable” command. Once we select it from the list of available commands the Command Manager shows the ID at the bottom where we can assign custom shortcuts. This is the number we need to use with the CallCommand() function.

The commands we need to perform in sequence are: Make Editable which converts the Extrude Nurbs in a hierarchy of separate polygon objects with the topmost selected. To connect these objects we need to select them: using the Select Children command we add the two child objects to the already selected parent polygon object. A last we use Connect+Delete to create a single polygon object and get rid of the separate parts.

After performing all those steps we end up with a single polygon object that is selected. The front and rear cap are still disconnected from the body though.

For the next step – Optimize – we switch from using CallCommand() to the c4d.utils module’s SendModelingCommand(). With CallCommand() we are limited to simple functions that do not require settings for the tool. Optimize has several options though that we cannot set using CallCommand().

The SendModelingCommand() requires several parameters. Beside the command itself it expects a list of objects and an optional BaseContainer object with the settings.

Here is the script:

First, we store the selected object after the Connect+Delete command for later use. We make sure that we have an selected object. If that is not the case we exit for now using return.

For the SendModelingCommand() function we need some settings. So we create an object of the type BaseContainer(). If that fails (ie. bc == None) we stop and exit the function again. If everything worked we continue.

We need to set all the parameters for the Optimize command by filling the BaseContainer bc with the according values using SetData(). We want to remove 1 and 2 point polygons, unused points, double points and merge all points within a certain tolerance (eg. 0.5 units). You can find the parameter names from the Python documentation. For some parameters you need to check out the C++ SDK documentation though.

To add Optimize to the Undo Stack we call the document’s AddUndo method. To make this work we need to add a StartUndo() and EndUndo() call outside our for-Loop also.

So here is the complete script:

Conclusion

As you can see we need to understand a few principles of Python and the internal workings of Cinema 4D to write a script. On the other hand it is not really hard once we overcome that hurdle. In the future it should be straight forward to replace our MakeExtrudeEditable() function with a function that performs different steps. The main part of getting all selected objects and traversing them to perform the desired steps remains the same. Taking a couple of minutes to think about a script and writing it certainly beats doing the same tedious task over and over again throughout a work day or even over weeks and months.

Putting it all together writing this simple script required to learn few principles:

• how to interact with the scene (the document) through BaseDocument class
• how to get the selected objects in a scene using GetActiveObjects
• using the for statement to go through that list
• writing our own function to capsulate the steps we want to perform on the objects
• using CallCommand() to use menu commands in our script
• using SendModelingCommand() to use more complex commands that require parameters
• a brief glimpse on how to use Undo()

Do you have a question or want to learn something specific? Leave a reply below or use the contact form from the top of the page!

There are different places in which you can use Python:

• as Python Script
• as Python Generator
• as Python Tag
• as Python Xpresso Node
• as Python Plugin

As you can see, there are plenty of options to use Python in Cinema 4D. For a start let us focus on using a Python script – ignoring the other possibilities for now.

Python Script

Python scripts are probably the most immediate way to perform automated tasks. To create a script open the Script Manager (Python) from the Python menu. Also open the Console (Python) from the same menu. The console will show you error messages and output from print statements in your Python script.

When you have not done something in Cinema 4D before the Script Manager should already contain this code:

The executed part

Now let us examine this a bit closer. For a start let us ignore the first few statements and look at the parts that actually do something:

This is the part that get’s executed when Cinema 4D runs the Python script. When a Python program is loaded as script, Python sets the variable __name__ to the value of “__main__”. This way a Python script knows it has been called as script rather than having been imported.

This brings us to the first statements – the import:

Imports

The import statement loads existing Python code from another file – a module. The Python binding to Cinema 4D is defined by the c4d module. By importing the c4d module you gain access to Cinema 4D’s functions through the API (Application Programming Interface). Within the c4d module there are several specialized packages that handle different parts of the API. One of those packages is c4d.gui that deals with the graphical user interface functions and classes.

This statements imports the gui package from the c4d module. This is an optional step that makes the gui functions available without the need to prefix them with the c4d module name (the namespace). Without the above statement you would have to explicitly prefix the gui.MessageDialog() function with c4d.

Condition and Code Block

Back to the actual code:

The conditional if statement checks the __name__ variable for the value of ‘__main__’. If this is true – so the program was loaded as script – the code block in the if statement is executed. Here, the previously defined function main() is called.

Print

Instead of defining a function first and then calling it when the script is executed you can also write your code here:

This would output the text “Hello World!” into the Python console rather than popping up a dialog window like MessageDialog() does. The advantage of print is that it does not interrupt the execution of the script like the dialog window that requires the user to press the OK button. So print is a great way of outputting debugging data to the console that can show you what is happening in your script. This makes it easier to find errors when something goes wrong. The disadvantage of print is that is only shows in the console which a normal user generally does not have open when using scripts. So avoid print for displaying data that is important to the user.

Functions

In the example code there is definition of the function main() that is being called from the script rather than immediate code:

This def statement defines a function named main(). The code following the definition is indented to contain the code block for the function. In this case a popup window with the text “Hello World!” is shown. This function only contains this one statement and does not have parameters or return values. We will have a look on how to use those in a later article.

In the example the function main() is called below using the statement main().

Summary

This was a very brief introduction into Python scripting in Cinema 4D by looking at the default script that is generated when opening the Script Manager.

What we have learned is:

• how Python scripts are executed in Cinema 4D (it defines __name__ as “__main__” conforming to general Python scripts)
• how Python can access Cinema 4D’s API through the c4d module and how to use import to use the c4d module and its packages
• how to use the print statement to output text to the Python console
• how to define a basic function using the def statement and how to call it

In future articles we actually will have a look at how to do something meaningful in a Python script like working with the current scene and how to use variables to store values and how to save your scripts so you can reuse them.

For further information have a look at the Python 2.6.4 documentation and Maxon’s documentation on their Python integration.

Do you have a question or want to learn something specific? Leave a reply below or use the contact form from the top of the page!

Widespread Industy Support…

So let’s have a brief look what applications support Python these days – and this list is definitely neither complete nor well researched as it is what comes to my mind right now:

3D Applications

• Maya (natively using MEL, a TCL dialect)
• Softimage (using the Windows scripting host, previously supported VBScript and JScript)
• Cinema 4D (with R12 Python is now officially supported, until then only COFFEE, a JavaScript like language was available for scripting)
• Modo (in addition to Perl and LUA)
• Houdini (starting to replacing HScript)
• Vue
• Blender
• Realflow
• Massive
• Renderfarm tools like RenderPal, Deadline, Cube!, DrQueue

VFX Applications

• Nuke (in addition to TCL)
• Fusion (in addition to eyeonscript which is based on LUA)
• Toxik – now bundled as Composite with Maya etc.

… means what?

That sound very promising. One might now think learning Python will allow you to script all those applications and use the same scripts with different applications. They all support Python, don’t they?

Unfortunately the language itself is just a minor part. Just like a C++ program does not automatically run on Windows, OSX and Linux a Python script does not work across applications. They integrate Python differently and more importantly, they have very different APIs (Application Programming Interfaces).

It not as grave though. Python clearly has the advantage that you do not need to learn the language each time, just broaden your vocabulary. Python is easy enough to be picked up by an artist but powerful enough to provide all the bells and whistles for an advanced programmer. So it scales well. Scripts grow in complexity over time and Python allows that without the need to resort to clumsy workarounds. It allows to build up libraries and resort to existing ones to build upon blocks of prior, tested code.

What now?

The first step in learning a programming language would be to get acquainted with its basic syntax. How to declare variables to store values and basic flow control. Luckily Python is pretty easy to pick up in this regard.

After knowing the basics you need to learn about you applications APIs that allow you to interact with your scene data. That’s more taxing. Some applications record your interaction into an log that shows what APIs were used. That is a good starting point to pick up the necessary functions to call. More often than not you would need to consult the documentation or get some scripts from the Web and examine them. Use them as starting points and modify them to do what you need.

Initial scripts should help you get things done faster. Often it’s enough to collect several steps you do manually into a script – making them work as macros that perform several steps at once. Next, you might want to give them some intelligence. Have some conditions in there that do things differently depending on what data they work or what parameters you provide for them. From there the sky is the limit.

Here is a small animation our team at Effects Garden did as season greetings. Enjoy!

Click here to view the video on YouTube.

These images are straight out of the renderer (Cinema 4D with V-Ray) without post work.

One great way to learn about camera work is Hollywood Camera Work Master Class. They now also released an add-on Hot Moves for those trailer-worthy shots. The master class is a great resource on learning how to block out shots – especially character driven ones. Hot moves is more about those “wow” moments.

Luckily, all those moves are relatively easy to do in CG at no cost. Once you start to move in the physical realm it really gets expensive and complicated. So enjoy what you can do in CG Oh, and pay close attention to your frame rates, exposure and shutter speeds while you are at it. It is equally important to the way you move your camera to get a great result.

Disclaimer: I am not affiliated with Hollywood Camera Work. I just happen to find their training videos a great resource that I like to recommend to you.

The number is the optical density which is the logarithm of the ratio of the light passing through the filter to the light entering the filter. Sounds complicated but isn’t really. An optical density of 0.3 reduces brightness by 50%, thus halfing it (1 stop in photography terms). The math is simple:  0.3 = -log₁₀ ( 0.5/1.0 ). 0.5 is the amount of light (intensity) passing through the filter, 1.0 is the intensity before the filter. (You can just get rid of that part in the equation as the intensity in front of the filter always is 1.0)

Still does not make sense?

Reversing it might help: With an optical density of 0.3 the amount of light passing through the filter is:  I = 10^-0.3 which is 0.5

So suddenly a filter of 1.0 or 1.5 makes sense:

10^-1.0 = 0.1 or 10%
10^-1.5 = 0.03 or 3%

Once I was past this hurdle it got a bit easier to grok and I was ready to learn why you should use an hot mirror when stepping down considerable and what the heck a hot mirror actually does – and how it relates to infrared and the properties of sensors (or film should you still work analog).

• nice resources for animators from Graphite 9