Pixel Sorting with OSC.

2024-05-17 10:02 UTC gpt-4o Open in ChatGPT ↗

To achieve this in TouchDesigner, you can follow these steps to drive the Displace Weight parameters with the incoming OSC values while ensuring the weights remain within the specified range of ‘-0.01 to 0.01’:

Set up OSC In CHOP:
- Add an OSC In CHOP to receive the incoming OSC values. Make sure you have the correct port and network settings to receive the OSC data.
- You should see the four channels corresponding to your OSC values.
Normalize OSC Values:
- To ensure that the OSC values map to the range of -0.01 to 0.01, use a Math CHOP.
- Connect the OSC In CHOP to the Math CHOP.
- In the Math CHOP parameters, set the From Range to the range of your OSC values. For instance, if your OSC values range from 0 to 1, set From Range to 0 to 1.
- Set the To Range to -0.01 to 0.01.
Displace TOP Setup:
- Add a Displace TOP to your network.
- Connect your input image to the first input of the Displace TOP.
- Set up the second input with the displacement map or texture you want to use for the pixel sorting effect.
Drive Displace Weight Parameters:
- In the Displace TOP parameters, locate the Displace Weight parameters.
- Use the values from the Math CHOP to drive these parameters. For instance, if you have four channels (e.g., chan1, chan2, chan3, chan4), you can reference these channels in the Displace Weight fields.
Reference Channels in Displace Weight:
- For the Displace Weight X and Displace Weight Y, use expressions to reference the channels from the Math CHOP.
- For example, if you want to use chan1 and chan2 for the X and Y displacement weights, respectively:
  - Set Displace Weight X to: chop("math1/chan1")
  - Set Displace Weight Y to: chop("math1/chan2")
- If you want to use all four channels, you can add them or use them in different ways. For instance:
  - Set Displace Weight X to: (chop("math1/chan1") + chop("math1/chan3")) / 2
  - Set Displace Weight Y to: (chop("math1/chan2") + chop("math1/chan4")) / 2

Here’s a step-by-step breakdown in pseudo-code for better understanding:

Add OSC In CHOP:
```
op('oscin1')
```
Add Math CHOP and connect OSC In CHOP:
```
op('oscin1').connect(op('math1'))
```

Set Math CHOP parameters:

op('math1').par.fromrange1 = 0
op('math1').par.fromrange2 = 1
op('math1').par.torange1 = -0.01
op('math1').par.torange2 = 0.01

Add Displace TOP and connect inputs:

op('displace1').input1 = op('yourInputImage')
op('displace1').input2 = op('yourDisplacementMap')

Set Displace Weight parameters using expressions:

op('displace1').par.displaceweightx.expr = 'chop("math1/chan1")'
op('displace1').par.displaceweighty.expr = 'chop("math1/chan2")'

This setup ensures your Displace Weight parameters are dynamically driven by your OSC values, maintaining the specified range. Adjust the expressions based on your specific requirements and the number of channels you want to use for the weights.

To change the font style of a Text TOP each time a cycle of a timer completes, you can use a script that updates the font parameter based on the current cycle count. Here’s how you can achieve this in TouchDesigner:

Set Up Timer CHOP:
- Add a Timer CHOP to your network.
- Configure the timer to cycle as needed.
Add a Text TOP:
- Add a Text TOP to your network to display the text.
- Connect the Timer CHOP to the Text TOP if you want to display the cycle count.
Create a List of Fonts:
- Define a list of font names you want to cycle through. You can use a DAT (Table DAT) to store the list of fonts.
Script to Change Font:
- Use a CHOP Execute DAT to run a script whenever the timer completes a cycle.
- In the script, update the font parameter of the Text TOP based on the current cycle count.

Here are the detailed steps:

Step-by-Step Guide

Set Up Timer CHOP:
- Add a Timer CHOP to your network and set its Cycle parameter as needed.
- Enable Output Cycle and Output Active.
Add a Text TOP:
- Add a Text TOP to your network.
- You can use the following expression to display the current cycle count:
```
op('timer1').par.cycle
```
Create a List of Fonts:
- Add a Table DAT and name it fontTable.
- Enter the names of the fonts you want to use in the table, one font per row.
Script to Change Font:
- Add a CHOP Execute DAT to your network.
- Connect the CHOP Execute DAT to the Timer CHOP.
- Set the CHOP Execute DAT to execute on cycle change:
  - Check the box for Off to On.

Write the Script:

In the CHOP Execute DAT, write the following script:

def onOffToOn(channel, sampleIndex, val, prev):
    # Get the current cycle count
    cycle_count = op('timer1').par.cycle.eval()

    # Get the list of fonts
    font_table = op('fontTable')
    num_fonts = font_table.numRows

    # Calculate the font index
    font_index = cycle_count % num_fonts

    # Get the font name
    font_name = font_table[font_index, 0].val

    # Set the font of the Text TOP
    op('text1').par.font = font_name

    return

Explanation

Timer CHOP: Tracks the cycles and triggers events on cycle completion.
Text TOP: Displays text and is updated with the new font style.
Table DAT (fontTable): Stores the list of fonts to cycle through.
CHOP Execute DAT: Executes a script on each cycle completion to update the font style.

This setup ensures that the font style of your Text TOP changes each time a cycle of the timer is completed. Adjust the font list in the Table DAT as needed to include all the fonts you want to cycle through.

Apologies for the confusion. The correct function to use in the CHOP Execute DAT is onOffToOn, which gets triggered when the value of the channel changes from off to on, such as when a cycle completes in the Timer CHOP. Here’s how to set up your CHOP Execute DAT correctly:

Set Up Timer CHOP:
- Add a Timer CHOP to your network and configure it to cycle as needed.
- Enable Output Cycle and Output Active.
Add a Text TOP:
- Add a Text TOP to your network to display the text.
- Optionally, you can use an expression to display the current cycle count:
```
`op('timer1').par.cycle`
```
Create a List of Fonts:
- Add a Table DAT and name it fontTable.
- Enter the names of the fonts you want to use in the table, one font per row.
Set Up CHOP Execute DAT:
- Add a CHOP Execute DAT to your network and connect it to the Timer CHOP.
- Configure the CHOP Execute DAT to trigger on the cycle change:
  - Check the offToOn box.
Write the Script:
- Edit the CHOP Execute DAT and write the following script:

def onOffToOn(channel, sampleIndex, val, prev):
    # Get the current cycle count
    cycle_count = int(op('timer1').par.cycle.eval())

    # Get the list of fonts
    font_table = op('fontTable')
    num_fonts = font_table.numRows

    # Calculate the font index
    font_index = cycle_count % num_fonts

    # Get the font name
    font_name = font_table[font_index, 0].val

    # Set the font of the Text TOP
    op('text1').par.font = font_name

    return

Explanation

Timer CHOP: Tracks the cycles and triggers events on cycle completion.
Text TOP: Displays text and is updated with the new font style.
Table DAT (fontTable): Stores the list of fonts to cycle through.
CHOP Execute DAT: Executes a script on each cycle completion to update the font style using the onOffToOn function.

It looks like we need to ensure we’re using the correct function in the CHOP Execute DAT to handle changes based on the Timer CHOP. Here’s a refined step-by-step guide to ensure everything works correctly:

Set Up Timer CHOP:
- Add a Timer CHOP to your network and configure it to cycle as needed.
- Enable Output Cycle and Output Active.
Add a Text TOP:
- Add a Text TOP to your network to display the text.
- Optionally, you can use an expression to display the current cycle count.
Create a List of Fonts:
- Add a Table DAT and name it fontTable.
- Enter the names of the fonts you want to use in the table, one font per row.
Set Up CHOP Execute DAT:
- Add a CHOP Execute DAT to your network and connect it to the Timer CHOP.
- Configure the CHOP Execute DAT to trigger on the offToOn transition:
  - Check the offToOn box.
Write the Script in CHOP Execute DAT:
- Edit the CHOP Execute DAT and write the following script in the onOffToOn function:

def onOffToOn(channel, sampleIndex, val, prev):
    # Get the current cycle count from Timer CHOP
    cycle_count = op('timer1').par.cycle

    # Get the list of fonts from the Table DAT
    font_table = op('fontTable')
    num_fonts = font_table.numRows

    # Calculate the font index based on the cycle count
    font_index = int(cycle_count) % num_fonts

    # Get the font name from the Table DAT
    font_name = font_table[font_index, 0].val

    # Set the font of the Text TOP
    op('text1').par.font = font_name

    return

Explanation

Timer CHOP: Tracks the cycles and outputs a signal when each cycle completes.
Text TOP: Displays the text and changes the font based on the cycle count.
Table DAT: Contains the list of fonts to cycle through, with each font on a new row.
CHOP Execute DAT: Runs the onOffToOn function when the Timer CHOP completes a cycle. This function:
- Retrieves the current cycle count.
- Determines the font index using the modulo operation with the number of fonts.
- Fetches the corresponding font name from the Table DAT.
- Updates the font parameter of the Text TOP with the new font name.

Additional Setup in TouchDesigner

Timer CHOP:
- Set the number of cycles you want.
- Ensure Output Cycle is checked so it outputs the cycle count.
- Optionally set the interval and other parameters as per your needs.
CHOP Execute DAT:
- Make sure the offToOn box is checked to trigger the script when the cycle count changes.

This approach ensures that the font style of your Text TOP changes every time the Timer CHOP completes a cycle, using the list of fonts specified in the Table DAT.

Please can we debug using print statements, this is the current code and I’m getting the same error:

def onOffToOn(channel, sampleIndex, val, prev): # Get the current cycle count from Timer CHOP cycle_count = op(‘timer1’).par.cycle

# Get the list of fonts from the Table DAT
font_table = op('fontTable')
num_fonts = font_table.numRows

# Calculate the font index based on the cycle count
font_index = int(cycle_count) % num_fonts

# Get the font name from the Table DAT
font_name = font_table[font_index, 0].val

# Set the font of the Text TOP
op('text1').par.font = font_name

return

Let’s add print statements to help debug the issue. These statements will help us understand the values of variables at each step and pinpoint where the problem might be occurring.

Here’s the updated script with debug print statements:

def onOffToOn(channel, sampleIndex, val, prev):
    print("Function triggered")

    # Get the current cycle count from Timer CHOP
    cycle_count = op('timer1').par.cycle.eval()
    print("Cycle count:", cycle_count)

    # Get the list of fonts from the Table DAT
    font_table = op('fontTable')
    num_fonts = font_table.numRows
    print("Number of fonts:", num_fonts)

    # Calculate the font index based on the cycle count
    font_index = int(cycle_count) % num_fonts
    print("Font index:", font_index)

    # Get the font name from the Table DAT
    font_name = font_table[font_index, 0].val
    print("Font name:", font_name)

    # Set the font of the Text TOP
    op('text1').par.font = font_name
    print("Font set to:", font_name)

    return

Steps to Implement

Set Up Timer CHOP:
- Add a Timer CHOP to your network and configure it to cycle as needed.
- Enable Output Cycle and Output Active.
Add a Text TOP:
- Add a Text TOP to your network to display the text.
Create a List of Fonts:
- Add a Table DAT and name it fontTable.
- Enter the names of the fonts you want to use in the table, one font per row.
Set Up CHOP Execute DAT:
- Add a CHOP Execute DAT to your network and connect it to the Timer CHOP.
- Configure the CHOP Execute DAT to trigger on the offToOn transition:
  - Check the offToOn box.
Write and Debug the Script:
- Edit the CHOP Execute DAT and write the above script in the onOffToOn function.

Debugging Process

Check Console Output:
- Once you run the Timer CHOP, check the console for the print statements.
- Verify each print statement to ensure values are as expected.
Adjust as Needed:
- If any value is not as expected, adjust your setup or script accordingly.

By following these steps and checking the debug print statements, you should be able to identify where the issue lies and fix it. If the function is not triggering at all, ensure that the CHOP Execute DAT is properly connected and configured to listen to the correct channel from the Timer CHOP.

From the error message in the console, it looks like the function onValueChange is not defined, but we are not actually using onValueChange. Instead, we need to ensure that onOffToOn is properly set up in the CHOP Execute DAT.

Here’s a detailed check and setup to make sure everything is correctly configured:

CHOP Execute DAT Setup:
- Ensure that the CHOP Execute DAT is properly configured to trigger on the offToOn transition.
- Check the parameters of the CHOP Execute DAT to confirm that only offToOn is checked. You do not need onValueChange unless you are tracking value changes.
Function Naming:
- Ensure that the function name in the CHOP Execute DAT is correctly defined as onOffToOn and not onValueChange.

Here are the exact steps:

Open the Parameters for CHOP Execute DAT:
- Click on the CHOP Execute DAT to open its parameters panel.
- Make sure only the offToOn box is checked, and uncheck any others if they are checked (like onValueChange).
Edit the Script:
- Open the CHOP Execute DAT and make sure the script is as follows:

def onOffToOn(channel, sampleIndex, val, prev):
    print("Function triggered")

    # Get the current cycle count from Timer CHOP
    cycle_count = int(op('timer3').par.cycle)
    print("Cycle count:", cycle_count)

    # Get the list of fonts from the Table DAT
    font_table = op('fontTable')
    num_fonts = font_table.numRows
    print("Number of fonts:", num_fonts)

    # Calculate the font index based on the cycle count
    font_index = cycle_count % num_fonts
    print("Font index:", font_index)

    # Get the font name from the Table DAT
    font_name = font_table[font_index, 0].val
    print("Font name:", font_name)

    # Set the font of the Text TOP
    op('text1').par.font = font_name
    print("Font set to:", font_name)

    return

Verifying Setup

Check the Script:
- Ensure that the function onOffToOn is correctly defined in the script and there is no other function named onValueChange unless necessary.
- Verify the function names in the CHOP Execute DAT callbacks section. It should only list onOffToOn.
Ensure Correct Connections:
- Make sure the CHOP Execute DAT is connected to the correct Timer CHOP.
- Ensure that the Text TOP is named text1 or change the script to match the actual name of your Text TOP.

Debugging Output

After making these changes, run the Timer and check the console output. The print statements should help you trace the values step-by-step to ensure the function is executing as expected.

If the setup is correct, this should resolve the issue and the font style should change with each cycle of the Timer. If there are any further issues, the debug print statements will help identify where the problem might be occurring.

Great it’s working now but the font index isn’t changing:

It looks like the cycle_count is not changing as expected, which is why the font index remains the same. This issue might be due to how the cycle_count is being retrieved from the Timer CHOP. Let’s make sure we are correctly referencing the cycle count and updating it with each cycle.

Here’s an updated version of the script with additional debug statements to check the value of cycle_count:

def onOffToOn(channel, sampleIndex, val, prev):
    print("Function triggered")

    # Get the current cycle count from Timer CHOP
    cycle_count = int(op('timer3').par.cycle.eval())
    print("Cycle count:", cycle_count)

    # Get the list of fonts from the Table DAT
    font_table = op('fontTable')
    num_fonts = font_table.numRows
    print("Number of fonts:", num_fonts)

    # Calculate the font index based on the cycle count
    font_index = cycle_count % num_fonts
    print("Font index:", font_index)

    # Get the font name from the Table DAT
    font_name = font_table[font_index, 0].val
    print("Font name:", font_name)

    # Set the font of the Text TOP
    op('text1').par.font = font_name
    print("Font set to:", font_name)

    return

Steps to Verify and Debug

Ensure Timer is Running:
- Make sure the Timer CHOP (timer3) is running and the cycle is incrementing.
- Verify the Timer CHOP settings: Output Cycle, Output Active, and any other relevant parameters should be correctly set.
Check cycle_count Output:
- Run the Timer CHOP and observe the console output for the value of cycle_count.
- Ensure that cycle_count is changing with each cycle.
Update Font Index:
- Verify the calculation of font_index using the modulo operation with num_fonts.

Additional Debugging Steps

If cycle_count is not changing, there might be an issue with how the Timer CHOP is set up or how we are referencing its parameters.

Timer CHOP Settings:
- Double-check the Timer CHOP settings to ensure it is set to cycle and increment the cycle count.
- Ensure Cycle Pulse or similar settings are correctly configured.
Manual Check:
- Manually check the value of op('timer3').par.cycle in the parameter window of the Timer CHOP to see if it increments as expected.

By following these steps, you should be able to identify if the cycle_count is correctly incrementing and ensure that the font index is updated with each cycle.

Same thing:

Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial Function triggered Cycle count: 1 Number of fonts: 4 Font index: 1 Font name: Arial Font set to: Arial python >>>

It looks like the cycle_count is not updating properly. Instead of using par.cycle, let’s use the cycle parameter from the Timer CHOP output directly, which will ensure that we get the latest cycle count.

Here’s an updated version of the script to ensure we get the correct cycle count:

Set up Timer CHOP correctly:
- Make sure your Timer CHOP is set to output cycle count and has the Cycle Pulse enabled.
Use a Select CHOP:
- Use a Select CHOP to directly get the cycle count from the Timer CHOP.
Modify the Script to Use the Select CHOP:

Here’s how to do it:

Step-by-Step Instructions

Add a Select CHOP:
- Add a Select CHOP to your network.
- In the Select CHOP parameters, select the Timer CHOP and set the channel name to be the cycle count output.
Modify the Script in CHOP Execute DAT:
- Use the cycle count from the Select CHOP in your script.

Here’s the complete code with debugging:

Updated Script

def onOffToOn(channel, sampleIndex, val, prev):
    print("Function triggered")

    # Get the current cycle count from the Select CHOP
    cycle_count = int(op('select1')[0])
    print("Cycle count:", cycle_count)

    # Get the list of fonts from the Table DAT
    font_table = op('fontTable')
    num_fonts = font_table.numRows
    print("Number of fonts:", num_fonts)

    # Calculate the font index based on the cycle count
    font_index = cycle_count % num_fonts
    print("Font index:", font_index)

    # Get the font name from the Table DAT
    font_name = font_table[font_index, 0].val
    print("Font name:", font_name)

    # Set the font of the Text TOP
    op('text1').par.font = font_name
    print("Font set to:", font_name)

    return

Explanation

Select CHOP: This will directly read the cycle count from the Timer CHOP.
- Ensure the Select CHOP points to the correct cycle channel of the Timer CHOP.
Script Modification:
- We use op('select1')[0] to get the current cycle count.
- Ensure select1 is the correct path to your Select CHOP.

Verifying Setup

Ensure Timer is Running:
- Verify the Timer CHOP is correctly configured to cycle and increment the cycle count.
Check Console Output:
- Run the Timer and observe the console output for the value of cycle_count.
- Ensure that cycle_count is changing with each cycle.

By directly using the cycle count from the Select CHOP, this should ensure that the value is correctly updated and reflected in the script, allowing the font index to change correctly.

The error you’re encountering, “NoneType object is not subscriptable,” suggests that op('select1') is not returning a valid CHOP reference. This might be due to an incorrect operator path or the CHOP not being properly set up.

Let’s go through the steps to ensure everything is correctly set up:

Verify the Select CHOP Setup:
- Ensure that the Select CHOP is correctly pointing to the Timer CHOP’s cycle count channel.
- Name the Select CHOP as select1 or update the script accordingly if it’s named differently.
Check the Cycle Count Channel:
- Make sure that the Select CHOP is correctly extracting the cycle count channel from the Timer CHOP.

Here’s a detailed setup guide:

Step-by-Step Setup

Add a Timer CHOP:
- Ensure the Timer CHOP is configured to cycle and output the cycle count.
- Check Output Cycle and ensure Cycle Pulse is enabled.
Add a Select CHOP:
- Add a Select CHOP to your network.
- In the Select CHOP parameters, set the CHOP parameter to the Timer CHOP and the Channel Name parameter to the cycle count channel (usually something like cycle).
Check the Select CHOP Output:
- Ensure that the Select CHOP is displaying the cycle count correctly.
Modify the Script in CHOP Execute DAT:

Here is the updated script with additional checks to ensure that the Select CHOP is correctly referenced:

def onOffToOn(channel, sampleIndex, val, prev):
    print("Function triggered")

    # Get the current cycle count from the Select CHOP
    select_chop = op('select1')
    if select_chop is None:
        print("Error: Select CHOP not found")
        return

    if len(select_chop.chans()) == 0:
        print("Error: No channels in Select CHOP")
        return

    cycle_count = int(select_chop[0])
    print("Cycle count:", cycle_count)

    # Get the list of fonts from the Table DAT
    font_table = op('fontTable')
    if font_table is None:
        print("Error: fontTable DAT not found")
        return

    num_fonts = font_table.numRows
    print("Number of fonts:", num_fonts)

    # Calculate the font index based on the cycle count
    font_index = cycle_count % num_fonts
    print("Font index:", font_index)

    # Get the font name from the Table DAT
    font_name = font_table[font_index, 0].val
    print("Font name:", font_name)

    # Set the font of the Text TOP
    text_top = op('text1')
    if text_top is None:
        print("Error: text1 TOP not found")
        return

    text_top.par.font = font_name
    print("Font set to:", font_name)

    return

Explanation

Select CHOP Verification:
- The script now checks if the Select CHOP is found and has channels before attempting to access its values.
Additional Checks:
- The script includes checks for the fontTable and text1 operators to ensure they are correctly referenced.
Cycle Count Retrieval:
- select_chop[0] is used to get the cycle count, and the script verifies this by printing the cycle count.

Verifying Setup

Ensure Timer is Running:
- Verify that the Timer CHOP is configured correctly to cycle and increment the cycle count.
Check Console Output:
- Run the Timer and observe the console output for the debug messages.
- Ensure the Select CHOP correctly outputs the cycle count and the script runs without errors.

By following these steps, you should be able to identify any issues with the Select CHOP setup and ensure the font index is correctly updated with each cycle of the Timer CHOP.