The Channel Class Wiki Documentation
Taking a little time to better understand the channel class provides a number of opportunities for getting a stronger handle on what’s happening in TouchDesigner. This can be especially helpful if you’re working with CHOP executes or just trying to really get a handle on what on earth CHOPs are all about.
To get started, it might be helpful to think about what’s really in a CHOP. Channel Operators are largely arrays (lists in python lingo) of numbers. These arrays can be only single values, or they might be a long set of numbers. In any given CHOP all of the channels will have the same length (we could also say that they have the same number of samples). That’s helpful to know as it might shape the way we think of channels and samples.
Before we go any further let’s stop to think through the above just a little bit more. Let’s first think about a constant CHOP with channel called ‘chan1’. We know we can write a python reference for this chop like this:
op( 'constant1' )[ 'chan1' ]
or like this:
op( 'constant1' )[ 0 ]
Just as a refresher, we should remember that the syntax here is:
op( stringNameToOperator )[ channelNameOrIndex ]
That’s just great, but what happens if we have a pattern CHOP? If we drop down a default pattern CHOP (which has 1000 samples), and we try the same expression:
op( 'pattern1' )[ 'chan1' ]
We now get a constantly changing value. What gives?! Well, we’re now looking at bit list of numbers, and we haven’t told Touch where in that list of values we want to grab an index – instead touch is moving through that index with me.time.frame-1 as the position in the array. If you’re scratching your head, that’s okay we’re going to pull this apart a little more.
Okay, what’s really hiding from us is that CHOP references have a default value that’s provided for us. While we often simplify the reference syntax to:
op( stringNameToOperator )[ channelNameOrIndex ]
In actuality, the real reference syntax is:
op( stringNameToOperator )[ channelNameOrIndex ][ arrayPosition ]
In single sample CHOPs we don’t usually need to worry about this third argument – if there’s only one value in the list Touch very helpfully grabs the only value there. In a multi-sample CHOP channel, however, we need more information to know what sample we’re really after. Let’s try our reference to a narrow down to a single sample in that pattern CHOP. Let’s say we want sample 499:
op( 'pattern1' )[ 'chan1' ][ 499 ]
With any luck you should now be seeing that you’re only getting a single value. Success!
But what does this have to do with the Channel Class? Well, if we take a closer look at the documentation ( Channel Class Wiki Documentation ), we might find some interesting things, for example:
Members
- valid (Read Only) True if the referenced chanel value currently exists, False if it has been deleted. Identical to bool(Channel).
- index (Read Only) The numeric index of the channel.
- name (Read Only) The name of the channel.
- owner (Read Only) The OP to which this object belongs.
- vals Get or set the full list of Channel values. Modifying Channel values can only be done in Python within a Script CHOP.
Okay, that’s great, but so what? Well, let’s practice our python and see what we might find if we try out a few of these members.
We might start by adding a pattern CHOP. I’m going to change my pattern CHOP to only be 5 samples long for now – we don’t need a ton of samples to see what’s going on here. Next I’m going to set up a table DAT and try out the following bits of python:
python
op( 'null1' )[0].valid
op( 'null1' )[0].index
op( 'null1' )[0].name
op( 'null1' )[0].owner
op( 'null1' )[0].exports
op( 'null1' )[0].vals
I’m going to plug that table DAT into an eval DAT to evaluate the python expressions so I can see what’s going on here. What I get back is:
True
0
chan1
/project1/base_the_channel_class/null1
[]
0.0 0.25 0.5 0.75 1.0
If we were to look at those side by side it would be:
| Python In | Python Out |
|---|---|
| op( ‘null1’ )[0].valid | True |
| op( ‘null1’ )[0].index | 0 |
| op( ‘null1’ )[0].name | chan1 |
| op( ‘null1’ )[0].owner | /project1/base_the_channel_class/null1 |
| op( ‘null1’ )[0].exports | [] |
| op( ‘null1’ )[0].vals | 0.0 0.25 0.5 0.75 1.0 |
So far that’s not terribly exciting… or is it?! The real power of these Class Members comes from CHOP executes. I’m going to make a quick little example to help pull apart what’s exciting here. Let’s add a Noise CHOP with 5 channels. I’m going to turn on time slicing so we only have single sample channels. Next I’m going to add a Math CHOP and set it to ceiling – this is going to round our values up, giving us a 1 or a 0 from our noise CHOP. Next I’ll add a null. Next I’m going to add 5 circle TOPs, and make sure they’re named circle1 – circle5.
Here’s what I want – Every time the value is true (1), I want the circle to be green, when it’s false (0) I want the circle to be red. We could set up a number of clever ways to solve this problem, but let’s imagine that it doesn’t happen too often – this might be part of a status system that we build that’s got indicator lights that help us know when we’ve lost a connection to a remote machine (this doesn’t need to be our most optimized code since it’s not going to execute all the time, and a bit of python is going to be simpler to write / read). Okay… so what do we put in our CHOP execute?! Well, before we get started it’s important to remember that our Channel class contains information that we might need – like the index of the channel. In this case we might use the channel index to figure out which circle needs updating. Okay, let’s get something started then!
python
def onValueChange(channel, sampleIndex, val, prev):
# set up some variables
offColor = [ 1.0, 0.0, 0.0 ]
onColor = [ 0.0, 1.0, 0.0 ]
targetCircle = 'circle{digit}'
# describe what happens when val is true
if val:
op( targetCircle.format( digit = channel.index + 1 ) ).par.fillcolorr = onColor[0]
op( targetCircle.format( digit = channel.index + 1 ) ).par.fillcolorg = onColor[1]
op( targetCircle.format( digit = channel.index + 1 ) ).par.fillcolorb = onColor[2]
# describe what happens when val is false
else:
op( targetCircle.format( digit = channel.index + 1 ) ).par.fillcolorr = offColor[0]
op( targetCircle.format( digit = channel.index + 1 ) ).par.fillcolorg = offColor[1]
op( targetCircle.format( digit = channel.index + 1 ) ).par.fillcolorb = offColor[2]
return
Alright! That works pretty well… but what if I want to use a select and save some texture memory?? Sure. Let’s take a look at how we might do that. This time around we’ll only make two circle TOPs – one for our on state, one for our off state. We’ll add 5 select TOPs and make sure they’re named select1-select5. Now our CHOP execute should be:
python
def onValueChange(channel, sampleIndex, val, prev):
# set up some variables
offColor = 'circle_off'
onColor = 'circle_on'
targetCircle = 'select{digit}'
# describe what happens when val is true
if val:
op( targetCircle.format( digit = channel.index + 1 ) ).par.top = onColor
# describe what happens when val is false
else:
op( targetCircle.format( digit = channel.index + 1 ) ).par.top = offColor
return
Okay… I’m going to add one more example to the sample code, and rather than walk you all the way through it I’m going to describe the challenge and let you pull it apart to understand how it works – challenge by choice, if you’re into what’s going on here take it all apart, otherwise you can let it ride.
Okay… so, what I want is a little container that displays a channel’s name, an indicator if the value is > 0 or < 0, another green / red indicator that corresponds to the >< values, and finally the text for the value itself. I want to use selects when possible, or just set the background TOP for a container directly. To make all this work you’ll probably need to use .name, .index, and .vals.
You can pull mine apart to see how I made it work here: base_the_channel_class.
Happy Programming!
BUT WAIT! THERE’S MORE!
Ivan DesSol asks some interesting questions:
Questions for the professor:
1) How can I find out which sample index in the channel is the current sample?
2) How is that number calculated? That is, what determines which sample is current?
If we’re talking about a multi sample channel let’s take a look at how we might figure that out. I mentioned this in passing above, but it’s worth taking a little longer to pull this one apart a bit. I’m going to use a constant CHOP and a trail CHOP to take a look at what’s happening here.
Let’s start with a simple reference one more time. This time around I’m going to use a pattern CHOP with 200 samples. I’m going to connect my pattern to a null (in my case this is null7). My resulting python should look like:
op( 'null7' )[ 'chan1' ]
Alright… so we’re speeding right along, and our value just keeps wrapping around. We know that our multi sample channel has an index, so for fun games and profit let’s try using me.time.frame:
op( 'null7' )[ 'chan1' ][ me.time.frame ]
Alright… well. That works some of the time, but we also get the error “Index invalid or out of range.” WTF does that even mean?! Well, remember an array or list has a specific length, when we try to grab something outside of that length we’ll seen an error. If you’re still stratching you’re head that’s okay – let’s take a look at it this way.
Let’s say we have a list like this:
fruit = [ apple, orange, kiwi, grape ]
We know that we can retrieve values from our list with an index:
print( fruit[ 0 ] ) | returns "apple"
print( fruit[ 1 ] ) | returns "orange"
print( fruit[ 2 ] ) | returns "kiwi"
print( fruit[ 3 ] ) | returns "grape"
If, however, we try:
print( fruit[ 4 ] )
Now we should see an out of range error… because there is nothing in the 4th position in our list / array. Okay, Matt – so how does that relate to our error earlier? The error we were seeing earlier is because me.time.frame (in a default network) evaluates up to 600 before going back to 1. So, to fix our error we might use modulo:
op( 'null7' )[ 'chan1' ][ me.time.frame % 200 ]
Wait!!! Why 200? I’m using 200 because that’s the number of samples I have in my pattern CHOP.
Okay! Now we’re getting somewhere.
The only catch is that if we look closely we’ll see that our refence with an index, and how touch is interpreting our previous refernce are different:
| refernce | value |
|---|---|
| op( ‘null7’ )[ ‘chan1’ ] | 0.6331658363342285 |
| op( ‘null7’ )[ ‘chan1’ ][ me.time.frame % 200 ] | 0.6381909251213074 |
WHAT GIVES MAAAAAAAAAAAAAAT!?
Alright, so there’s one more thing for us to keep in mind here. me.time.frame starts sequencing at 1. That makes sense, because we don’t usually think of frame 0 in animation we think of frame 1. Okay, cool. The catch is that our list indexes from the 0 position – in programming languages 0 still represents an index position. So what we’re actually seeing here is an off by one error.
Now that we now what the problem is it’s easy to fix:
op( 'null7' )[ 'chan1' ][ ( me.time.frame - 1 ) % 200 ]
Now we’re right as rain:
| refernce | value |
|---|---|
| op( ‘null7’ )[ ‘chan1’ ] | 0.6331658363342285 |
| op( ‘null7’ )[ ‘chan1’ ][ me.time.frame ] | 0.6381909251213074 |
| op( ‘null7’ )[ ‘chan1’ ][ ( me.time.frame – 1 ) % 200 ] | 0.6331658363342285 |
Hope that helps!
Matthew Ragan 