Font Switching Based on OSC

2024-06-24 11:36 UTC gpt-4o Open in ChatGPT ↗

In touch designer I’ve got this script which I’m using to monitor osc inputs and then based on whichever channel has the highest value, select from 4 different tables and switch the font of a Text TOP. This is where we’re at: def valueChange(channel, sampleIndex, val, prev): # Get the operator (CHOP) this DAT is monitoring chop = channel.owner

# Get the values of the channels
angel = chop['angel'][0]
hero = chop['hero'][0]
feminist = chop['feminist'][0]
rebel = chop['rebel'][0]

# Find the channel with the highest value
values = [angel, hero, feminist, rebel]
max_index = values.index(max(values))

# Define the paths or names of the Chop Execute DATs
chop_exec_dats = [
    op('Angel_Fonts'),
    op('Hero_Fonts'),
    op('Feminist_Fonts'),
    op('Rebel_Fonts')
]

# Turn on the Chop Execute DAT with the highest value and turn off the others
for i, chop_exec_dat in enumerate(chop_exec_dats):
    chop_exec_dat.par.active = (i == max_index)

return

Your script is already quite good. It correctly identifies the highest value among the channels and activates the corresponding font table while deactivating the others. However, I noticed a few points where it could be slightly improved for better readability and functionality. Here’s a refined version of your script:

def valueChange(channel, sampleIndex, val, prev):
    # Get the operator (CHOP) this DAT is monitoring
    chop = channel.owner

    # Get the values of the channels
    angel = chop['angel'][0]
    hero = chop['hero'][0]
    feminist = chop['feminist'][0]
    rebel = chop['rebel'][0]

    # Find the channel with the highest value
    values = [angel, hero, feminist, rebel]
    max_index = values.index(max(values))

    # Define the paths or names of the Chop Execute DATs
    chop_exec_dats = [
        op('Angel_Fonts'),
        op('Hero_Fonts'),
        op('Feminist_Fonts'),
        op('Rebel_Fonts')
    ]

    # Turn on the Chop Execute DAT with the highest value and turn off the others
    for i, chop_exec_dat in enumerate(chop_exec_dats):
        chop_exec_dat.par.active = (i == max_index)

    # Change the font of the Text TOP based on the active Chop Execute DAT
    text_top = op('text_top')  # Replace with the actual name of your Text TOP operator
    font_tables = [
        op('Angel_Fonts'),
        op('Hero_Fonts'),
        op('Feminist_Fonts'),
        op('Rebel_Fonts')
    ]

    active_font_table = font_tables[max_index]
    text_top.par.fontfile = active_font_table['fontfile'][0]  # Assuming 'fontfile' column contains the font path

    return

Explanation:

Identifying the highest value: The script first gathers values from the specified channels and identifies which one is the highest.
Activating the correct Chop Execute DAT: The script then activates the corresponding Chop Execute DAT (which contains font information) and deactivates the others.
Changing the font of the Text TOP: The script updates the font of a Text TOP based on the active Chop Execute DAT. It assumes that the font path is stored in a column named fontfile in each font table.

Assumptions:

The Text TOP operator is named text_top.
Each font table (e.g., Angel_Fonts, Hero_Fonts, etc.) has a column named fontfile that contains the path to the font file.

Ensure that the names of your operators and columns match those used in the script. If they differ, you’ll need to adjust the script accordingly.

Got it! Since you want to randomly select a font from the highest value category and set it to the font parameter of the Text TOP, we can adjust the script accordingly.

Here is an updated version of the script that includes the random selection of the font from the highest category:

import random

def valueChange(channel, sampleIndex, val, prev):
    # Get the operator (CHOP) this DAT is monitoring
    chop = channel.owner

    # Get the values of the channels
    angel = chop['angel'][0]
    hero = chop['hero'][0]
    feminist = chop['feminist'][0]
    rebel = chop['rebel'][0]

    # Find the channel with the highest value
    values = [angel, hero, feminist, rebel]
    max_index = values.index(max(values))

    # Define the paths or names of the Chop Execute DATs
    chop_exec_dats = [
        op('Angel_Fonts'),
        op('Hero_Fonts'),
        op('Feminist_Fonts'),
        op('Rebel_Fonts')
    ]

    # Turn on the Chop Execute DAT with the highest value and turn off the others
    for i, chop_exec_dat in enumerate(chop_exec_dats):
        chop_exec_dat.par.active = (i == max_index)

    # Change the font of the Text TOP based on the active Chop Execute DAT
    text_top = op('static_text')  # Replace with the actual name of your Text TOP operator
    font_table = chop_exec_dats[max_index]

    # Get all fonts from the selected font table
    fonts = [row[0].val for row in font_table.rows()]

    # Select a random font from the list
    selected_font = random.choice(fonts)

    # Set the selected font to the Text TOP
    text_top.par.font = selected_font

    return

Explanation:

Import the random module: This allows us to randomly select a font from the list.
Gather the values: Collect the values from the different channels.
Find the highest value: Determine which channel has the highest value.
Activate the corresponding font table: Activate the Chop Execute DAT for the highest value and deactivate the others.
Select a random font: From the active font table, select a random font.
Set the font: Assign the randomly selected font to the font parameter of the Text TOP.

Ensure the name of your Text TOP operator is correctly specified as static_text. Adjust the name in the script if necessary. This script should now achieve the desired functionality.

The error indicates that par.active is not available in this context. Instead, you might want to directly work with the fonts in your Text TOP without trying to activate or deactivate any operators.

Here’s a refined version of your script:

import random

def valueChange(channel, sampleIndex, val, prev):
    # Get the operator (CHOP) this DAT is monitoring
    chop = channel.owner

    # Get the values of the channels
    angel = chop['angel'][0]
    hero = chop['hero'][0]
    feminist = chop['feminist'][0]
    rebel = chop['rebel'][0]

    # Find the channel with the highest value
    values = [angel, hero, feminist, rebel]
    max_index = values.index(max(values))

    # Define the paths or names of the Font Tables
    font_tables = [
        op('Angel_Fonts'),
        op('Hero_Fonts'),
        op('Feminist_Fonts'),
        op('Rebel_Fonts')
    ]

    # Select the active font table based on the highest value
    active_font_table = font_tables[max_index]

    # Get all fonts from the selected font table
    fonts = [row[0].val for row in active_font_table.rows()]

    # Select a random font from the list
    selected_font = random.choice(fonts)

    # Set the selected font to the Text TOP
    text_top = op('static_text')  # Replace with the actual name of your Text TOP operator
    text_top.par.font = selected_font

    return

Changes made:

Removed the active parameter handling: Since par.active is not applicable here, I removed the logic that tries to activate/deactivate the Chop Execute DATs.
Directly selected the active font table: Based on the highest value, the script selects the corresponding font table.
Selected a random font from the active table: Randomly picked a font from the selected font table and set it to the font parameter of the Text TOP.

This should avoid the AttributeError and properly select and set a random font from the appropriate font table.

To add the functionality where the color of the table currently being used changes to green, you can use the par.bgcolorr (for red), par.bgcolorg (for green), and par.bgcolorb (for blue) parameters of each table to set their background colors.

Here’s how you can modify the script to include this feature:

import random

def valueChange(channel, sampleIndex, val, prev):
    # Get the operator (CHOP) this DAT is monitoring
    chop = channel.owner

    # Get the values of the channels
    angel = chop['angel'][0]
    hero = chop['hero'][0]
    feminist = chop['feminist'][0]
    rebel = chop['rebel'][0]

    # Find the channel with the highest value
    values = [angel, hero, feminist, rebel]
    max_index = values.index(max(values))

    # Define the paths or names of the Font Tables
    font_tables = [
        op('Angel_Fonts'),
        op('Hero_Fonts'),
        op('Feminist_Fonts'),
        op('Rebel_Fonts')
    ]

    # Select the active font table based on the highest value
    active_font_table = font_tables[max_index]

    # Get all fonts from the selected font table
    fonts = [row[0].val for row in active_font_table.rows()]

    # Select a random font from the list
    selected_font = random.choice(fonts)

    # Set the selected font to the Text TOP
    text_top = op('static_text')  # Replace with the actual name of your Text TOP operator
    text_top.par.font = selected_font

    # Set the background color of all tables to black and active one to green
    for i, font_table in enumerate(font_tables):
        if i == max_index:
            font_table.par.bgcolorr = 0
            font_table.par.bgcolorg = 1
            font_table.par.bgcolorb = 0
        else:
            font_table.par.bgcolorr = 0
            font_table.par.bgcolorg = 0
            font_table.par.bgcolorb = 0

    return

Explanation:

Define background color parameters: par.bgcolorr, par.bgcolorg, and par.bgcolorb are used to set the background color of the table.
Set active table color to green: For the table with the highest value, set the background color to green ((0, 1, 0)).
Set other tables color to black: For the other tables, set the background color to black ((0, 0, 0)).

This will change the background color of the active table to green and the others to black. Make sure that the table operators have the bgcolorr, bgcolorg, and bgcolorb parameters available for this to work.

The error suggests that bgcolorr, bgcolorg, and bgcolorb parameters might not be available for your table operators. Instead, you can use a different approach to visually indicate which table is active, such as changing the text color within the table cells or highlighting the border.

Here’s an alternative approach where we change the text color of the table cells:

import random

def valueChange(channel, sampleIndex, val, prev):
    # Get the operator (CHOP) this DAT is monitoring
    chop = channel.owner

    # Get the values of the channels
    angel = chop['angel'][0]
    hero = chop['hero'][0]
    feminist = chop['feminist'][0]
    rebel = chop['rebel'][0]

    # Find the channel with the highest value
    values = [angel, hero, feminist, rebel]
    max_index = values.index(max(values))

    # Define the paths or names of the Font Tables
    font_tables = [
        op('Angel_Fonts'),
        op('Hero_Fonts'),
        op('Feminist_Fonts'),
        op('Rebel_Fonts')
    ]

    # Select the active font table based on the highest value
    active_font_table = font_tables[max_index]

    # Get all fonts from the selected font table
    fonts = [row[0].val for row in active_font_table.rows()]

    # Select a random font from the list
    selected_font = random.choice(fonts)

    # Set the selected font to the Text TOP
    text_top = op('static_text')  # Replace with the actual name of your Text TOP operator
    text_top.par.font = selected_font

    # Change the text color of all tables to white and active one to green
    for i, font_table in enumerate(font_tables):
        if i == max_index:
            for cell in font_table.col(0):
                cell.bgcolorr = 0
                cell.bgcolorg = 1
                cell.bgcolorb = 0
        else:
            for cell in font_table.col(0):
                cell.bgcolorr = 1
                cell.bgcolorg = 1
                cell.bgcolorb = 1

    return

Explanation:

Change cell background color: Iterate through the cells of the first column of each table and change the background color to green for the active table and to white for the others.

This approach should work, assuming your table cells have the bgcolorr, bgcolorg, and bgcolorb attributes. If these attributes are also unavailable, you might need to explore other methods such as using external indicators or annotations within your interface.

In this script ensure that the text being parsed to the input text is always capitalised:

import random

def update_text(): # Get references to the Table DATs angel_table = op(‘angel_table’) hero_table = op(‘hero_table’) feminist_table = op(‘feminist_table’) rebel_table = op(‘rebel_table’)

# Get references to the Text TOP
text_top = op('input_text')

# Read words from each table
all_words = []

for table in [angel_table, hero_table, feminist_table, rebel_table]:
    # Collect all words from the current table
    words = [row[0].val for row in table.rows() if len(row) > 0 and row[0].val.strip()]
    all_words.extend(words)

# Pick up to 1 words at random from all words
random_words = random.sample(all_words, min(len(all_words), 1))

# Join the words into a single string separated by spaces
input_text = ' '.join(random_words)

# Update the Text TOP
text_top.par.text = input_text

return

Call the update_text function to update the Text TOP

update_text()

To ensure that the text being parsed to the Text TOP is always capitalized, you can use the upper() method to convert the text to uppercase. Here’s how you can modify the script:

import random

def update_text():
    # Get references to the Table DATs
    angel_table = op('angel_table')
    hero_table = op('hero_table')
    feminist_table = op('feminist_table')
    rebel_table = op('rebel_table')

    # Get references to the Text TOP
    text_top = op('input_text')

    # Read words from each table
    all_words = []

    for table in [angel_table, hero_table, feminist_table, rebel_table]:
        # Collect all words from the current table
        words = [row[0].val for row in table.rows() if len(row) > 0 and row[0].val.strip()]
        all_words.extend(words)

    # Pick up to 1 words at random from all words
    random_words = random.sample(all_words, min(len(all_words), 1))

    # Join the words into a single string separated by spaces and capitalize
    input_text = ' '.join(random_words).upper()

    # Update the Text TOP
    text_top.par.text = input_text

    return

# Call the update_text function to update the Text TOP
update_text()

Explanation:

Convert to Uppercase: The line input_text = ' '.join(random_words).upper() ensures that the resulting text is converted to uppercase before being assigned to the text parameter of the Text TOP.

This ensures that regardless of the original casing of the words in the tables, the text displayed in the Text TOP will always be in uppercase.

The error indicates that the script might be running in a context where it expects to find a function named oncook. In TouchDesigner, oncook is a method associated with a script DAT that is executed every time the DAT cooks.

To resolve this issue, you can place your script in a Script DAT and make sure the function update_text is called within the oncook method.

Here’s how to properly set it up in a Script DAT:

Create a new Script DAT (e.g., text_update).
Add the following code to the Script DAT:

import random

def update_text():
    # Get references to the Table DATs
    angel_table = op('angel_table')
    hero_table = op('hero_table')
    feminist_table = op('feminist_table')
    rebel_table = op('rebel_table')

    # Get references to the Text TOP
    text_top = op('input_text')

    # Read words from each table
    all_words = []

    for table in [angel_table, hero_table, feminist_table, rebel_table]:
        # Collect all words from the current table
        words = [row[0].val for row in table.rows() if len(row) > 0 and row[0].val.strip()]
        all_words.extend(words)

    # Pick up to 1 words at random from all words
    random_words = random.sample(all_words, min(len(all_words), 1))

    # Join the words into a single string separated by spaces and capitalize
    input_text = ' '.join(random_words).upper()

    # Update the Text TOP
    text_top.par.text = input_text

    return

def oncook(dat):
    update_text()

Explanation:

Define the update_text function: This function contains the logic to select and capitalize the text.
Define the oncook function: This function calls update_text every time the Script DAT cooks.
Call update_text within oncook: This ensures the text is updated every time the Script DAT is cooked.

Setting up the Script DAT to cook:

Attach the Script DAT to a network or event that causes it to cook regularly. For example, you can connect it to a CHOP Execute DAT or set it to cook based on a timer or other triggers in your TouchDesigner project.

This setup will ensure that the update_text function is called appropriately, and the text in the Text TOP will be updated and capitalized as required.