# Stumbling Toward 'Awesomeness'

A Technical Art Blog

## Tuesday, October 25, 2011

### Quick Note About Range(), Modulus, and Step

Maybe it’s me, but I often find myself parsing weird ascii text files from others. Sometimes the authors knew what the data was and there’s no real markup. Take this joint list for example:

```143 # bones root ground -1 0 0 0 root hips 0 0 0.9512207 6E-08 spine 1 1 4E-08 0.9522207 1.4E-07 spine 2 2 3E-07 1.0324 8.3E-07 spine 3 3 5.6E-07 1.11357 1.53E-06 spine 4 4 8.2E-07 1.194749 2.22E-06 head neck lower```

So the first line is the number of joints then it begins in three line intervals stating from the root outwards: joint name, parent integer, position. I used to make a pretty obtuse loop using a modulus operator. Basically, modulus is the remainder left over after division. So X%Y gives you the remainder of X divided by Y; here’s an example:

```for i in range(0,20+1): if i%2 == 0: print i #>> 0 #>> 2 #>> 4 #>> 6 #>> 8 #>> 10```

The smart guys out there see where this is goin.. so I never knew range had a ‘step’ argument. (Or I believe I did, I think I actually had this epiphany maybe two years ago, but my memory is that bad.) So parsing the above is as simple as this:

```jnts = [] for i in range(1,numJnts*3+1,3): jnt = lines[i].strip() parent = int(lines[i+1].strip()) posSplit = lines[i+2].strip().split(' ') pos = (float(posSplit[0])*jointScale, \ float(posSplit[1])*jointScale, float(posSplit[2])*jointScale) jnts.append([jnt, parent, pos])```

Thanks to phuuchai on #python (efnet) for nudging me to RTFM!

posted by admin at 1:42 AM

## Wednesday, October 12, 2011

### SIGGRAPH 2011: Intro To Python Course

I gave a workshop/talk at SIGGRAPH geared toward introducing people to Python. There were ~25 people on PCs following along, and awkwardly enough, many more than that standing and watching. I prefaced my talk with the fact that I am self-taught and by no means an expert. That said, I have created many python tools people use every day at industry-leading companies.

Starting from zero, in the next hour I aimed to not only introduce them to Python, but get them doing cool, usable things like:

• Iterating through batches/lists
• Reading / writing data to excel files
• Wrangling data from one format to another in order to create a ‘tag cloud’

Many people have asked for the notes, and I only had rough notes. I love Python, and I work with this stuff every day, so I have had to really go back and flesh out some of what I talked about. This tutorial has a lot less of the general chit-chat and information. I apologize for that.

# Installation / Environment Check

Let’s check to see that you have the tools properly installed. If you open the command prompt and type ‘python’ you should see this:

So Python is correctly installed, for the following you can either follow along in the cmd window (more difficult) or in IDLE, the IDE that python ships with (easier). This can be found by typing IDLE into the start menu:

# Variables

Variables are pieces of information you store in memory, I will talk a bit about different types of variables.

### Strings

Strings are pieces of text. I assume you know that, so let’s just go over some quick things:

```string = 'this is a string' print string #>>this is a string num = '3.1415' print num #>>3.1415```

One thing to keep in mind, the above is a string, not a number. You can see this by:

```print num + 2 #>>Traceback (most recent call last): #>> File "basics_variables.py", line 5, in #>> print num + 2 #>>TypeError: cannot concatenate 'str' and 'int' objects```

Python is telling you that you cannot add a number to a string of text. It does not know that ‘3.1415’ is a number. So let’s convert it to a number, this is called ‘casting’, we will ‘cast’ the string into a float and back:

```print float(num) + 2 #>>5.1415 print str(float(num) + 2) + ' addme' #>>5.1415 addme```

### Lists

Lists are the simplest ways to store pieces of data. Let’s make one by breaking up a string:

```txt = 'jan tony senta michael brendon phillip jonathon mark' names = txt.split(' ') print names #>>['jan', 'tony', 'senta', 'michael', 'brendon', 'phillip', 'jonathon', 'mark'] for item in names: print item #>>jan #>>tony #>>senta #>>michael ...```

Split breaks up a string into pieces. You tell it what to break on, above, I told it to break on spaces txt.split(‘ ‘). So all the people are stored in a List, which is like an Array or Collection in some other languages.
You can call up the item by it’s number starting with zero:

```print names[0], names[5] #>>jan phillip```

TIP: [-1] index will return the last item in an array, here’s a quick way to get a file from a path:

```path = 'D:\\data\\dx11_PC_(110)_05_09\\Tools\\CryMaxInstaller.exe' print path.split('\\')[-1] #>>CryMaxInstaller.exe```

### Dictionaries

These store keys, and the keys reference different values. Let’s make one:

```dict = {'sascha':'tech artist', 'harry': 142.1, 'sean':False} print dict['sean'] #>>False```

So this is good, but these are just the keys, we need to know the values. Here’s another way to do this, using .keys()

```dict = {'sascha':'tech artist', 'harry': 142.1, 'sean':False} for key in dict.keys(): print key, 'is', dict[key] #>>sean is False #>>sascha is tech artist #>>harry is 142.1```

So, dictionaries are a good way to store simple relationships of key and value pairs. In case you hadn’t notices, I used some ‘floats’ and ‘ints’ above. A float is a number with a decimal, like 3.1415, and an ‘int’ is a whole number like 10.

# Creating Methods (Functions)

A method or function is like a little tool that you make. These building blocks work together to make your program.

Let’s say that you have to do something many times, you want to re-use this code and not copy/paste it all over. Let’s use the example above of names, let’s make a function that takes a big string of names and returns an ordered list:

```def myFunc(input): people = input.split(' ') people = sorted(people) return people txt = 'jan tony senta michael brendon phillip jonathon mark' orderedList = myFunc(txt) print orderedList #>>['brendon', 'jan', 'jonathon', 'mark', 'michael', 'phillip', 'senta', 'tony']```

# Basic Example: Create A Tag Cloud From an Excel Document

So we have an excel sheet, and we want to turn it into a hip â€˜tag cloudâ€™ to get peopleâ€™s attention.
If we go to http://www.wordle.net/ you will see that in order to create a tag cloud, we need to feed it the sentences multiple times, and we need to put a tilde in between the words of the sentence. We can automate this with Python!

First, download the excel sheet from me here: [info.csv] The CSV filetype is a great way to read/write docs easily that you can give to others, they load in excel easily.

```file = 'C:\\Users\\chris\\Desktop\\intro_to_python\\info.csv' f = open(file, 'r') lines = f.readlines() f.close() print lines #>> ['always late to work,13\n', 'does not respect others,1\n', 'does not check work properly,5\n', 'does not plan properly,4\n', 'ignores standards/conventions,3\n']```

â€˜\nâ€™ is a line break character, it means â€˜new lineâ€™, we want to get rid of that, we also want to just store the items, and how many times they were listed.

```file = 'C:\\Users\\chris\\Desktop\\intro_to_python\\info.csv' f = open(file, 'r') lines = f.readlines() f.close() dict = {} for line in lines: split = line.strip().replace(' ','~').split(',') dict[split[0]] = int(split[1]) print dict #>>{'ignores~standards/conventions': 3, 'does~not~respect~others': 1, 'does~not~plan~properly': 4, 'does~not~check~work~properly': 5, 'always~late~to~work': 13}```

Now we have the data in memory in an easily readable way, letâ€™s write it out to disk.

```output = '' for key in dict.keys(): for i in range(0,dict[key]): output += (key + '\n') f = open('C:\\Users\\chris\\Desktop\\intro_to_python\\test.txt', 'w') f.write(output) f.close()```

There we go. In one hour you have learned to:

• Read and write excel files
• Iterate over data
• Convert data sets into new formats
• Write, read and alter ascii files

If you have any questions, or I left out any parts of the presentation you liked, reply here and I will get back to you.

posted by admin at 5:12 AM

## Tuesday, October 4, 2011

As many of you know, I feel the whole ‘autorigging’ schtick is a bit overrated. Though Bungie gave a great talk at GDC09 (Modular Procedural Rigging), Dice was to give one this year at SIGGRAPH (Modular Rigging in Battlefield 3), but never showed up for the talk.

At Crytek we are switching our animation dept from 3dsMax to Maya. This forces us to build a pipeline there from scratch; in 3dsMax we had 7 years of script development focused on animation and rigging tools. So I am looking at quite a bit o Maya work. The past two weeks focusing on a ‘rigging system’ that I guess could be thought of as ‘procedural’ but is not really an ‘autorigger’. My past experience was always regenerating rigs with mel cmds.

Things I would like to solve:

• Use one set of animator tools for many rigs – common interfaces, rig block encapsulation (oh god i said ‘block’)
• Abstract things away, thinking of rigging ‘units’ and character ‘parts’ instead of individual rig elements, break reliance on naming, version out different parts
• Be fluid enough to regenerate the ‘rigging’ at any time

### First Weekend: Skeleton ‘Tagging’

I created a wrapper around the common rigging tools that I used, this way, when I rigged, it would automagically markup the skeleton/elements as I went. This looked like so:

The foundation of this was marking up the skeleton or cons with message nodes that pointed to things or held metadata.Â  This was cool, and I still like how simple it was, however, it didn’t really create the layer of abstraction I was after. There wasn’t the idea of a limb that I could tell to switch from FK to IK.

### Second Weekend: Custom Nodes

That Bungie talk got a lot of us all excited, Roman went and created a really cool custom node plugin that does way more than we spec’d it out to do. I rewrote the rigging tools to create ‘rigPart’ nodes, which could be like an IK chain, set of twist joints, expression, or constraint. These together could form a ‘charPart’ like an arm or leg. All these nodes sat under a main ‘character’ node. I realize that many companies abstract their characters into ‘blocks’ or ‘parts’, but I had never seen a system that had another layer underneath that. Roman also whipped up a way that when an attr on a customNode changes, you could evaluate a script. So whether it’s a human arm or alien tentacle arm, the ‘charPart’ node can have one FK/IK enum. I am still not sure if this is a better idea, because of the sheer legwork involved..

### Third Weekend: A Mix of Both?

So a class like ‘charParts.gruntLeg()’ not only knew how to build the leg rigParts, but also only the leg ‘rigging’ if needed. This works pretty well, but the above was pretty hard to read. I took some of my favorite things about the tree-view-based system and I created a ‘character’ outliner of sorts. This made it much easier to visualize the rigParts that made up individual ‘systems’ of the character, like leg, spine, arm, etc. I did it as a test, but in a way that I easily swap it out with the treeWidget in the rigging tools dialog.

So how do you guys solve some of these issues?

posted by Chris at 4:00 AM

## Sunday, October 2, 2011

### Creatures and Anatomy: Reticulated Python

Pythons have probably my favorite skull of any animal. The reticulated python has a jaw that is in four movable parts, and the lower two can swing open over 120 degrees. Here are the main parts of a reticulated python skull:

Via SkullsUnlimited.com

Four, independently moving jaw bones, in case you thought Predator or the Covenant were original: Mother Nature has had them beat for a while!Â  –And look at the angle of those teeth: nothing that goes into that mouth is ever coming out! Here’s a video of a guy getting bitten and his friends have to push the skull forward very hard, then open the mouth, and then pull it away. With these four independent jaw parts, they have the ability to really get their mouths around prey that is much larger than their bodies, like this African antelope:

I marked the mouth in red above

As if four independently moving jaw parts wasn’t cool enough: they have a second row of teeth! These are situated on the roof of their mouth, yes, you read that right, reticulated pythons have palatine teeth, circled below:

This is a central row of teeth behind the maxillary teeth on the upper jaw! Here are some better pics to make it harder for you to get to sleep at night:

Here’s a link to a 3d Burmese Python skull 360 render (roll) from the DigiMorph website.

posted by admin at 3:45 PM