Touch Comm OSC UI

2024-04-26 11:37 UTC gpt-4 Open in ChatGPT ↗

You

We’re working with the Processing script and touch designer:

import oscP5.; import netP5.;

OscP5 oscP5; NetAddress touchDesignerAddress;

String inputText = ""; // Stores the user input String placeholderText = “Input Text”; // Placeholder text for input int[] outputValues = new int[4]; // Array to store the randomized outputs String[] labels = {“Angel: ”, “Hero: ”, “Feminist: ”, “Rebel: ”}; // Labels for outputs

int inputBoxX = 50, inputBoxY = 100, inputBoxWidth = 400, inputBoxHeight = 50; int outputBoxY = 180; // Y position of the output boxes boolean showCursor = true; int cursorPosition = 0; // Position of cursor within inputText int cursorTimer = 0; int textOffset = 10; // X offset for text start inside input box

void setup() { size(500, 500); oscP5 = new OscP5(this, 12000); touchDesignerAddress = new NetAddress(“127.0.0.1”, 9000); textAlign(LEFT, CENTER); textFont(createFont(“Helvetica”, 18)); }

void draw() { background(245, 245, 245); fill(50); textSize(24); text(“Florence Nightingale - Living Portrait”, 20, 50);

// Input box interaction stroke(200); fill(255); rect(inputBoxX, inputBoxY, inputBoxWidth, inputBoxHeight, 10);

// Text rendering in input box fill(0); textSize(18); if (inputText.equals("") && !focused) { fill(150); text(placeholderText, inputBoxX + textOffset, inputBoxY + inputBoxHeight / 2); } else { fill(0); text(inputText.substring(0, cursorPosition) + (showCursor ? ”|” : "") + inputText.substring(cursorPosition), inputBoxX + textOffset, inputBoxY + inputBoxHeight / 2); }

// Output boxes and labels textSize(16); for (int i = 0; i < 4; i++) { int boxY = outputBoxY + i * 60; fill(255); stroke(200); rect(inputBoxX, boxY, inputBoxWidth, 40, 10); fill(0); text(labels[i] + outputValues[i], inputBoxX + 10, boxY + 25); }

// Cursor blink management cursorTimer++; if (cursorTimer >= 30) { showCursor = !showCursor; cursorTimer = 0; } }

void mousePressed() { if (mouseX > inputBoxX && mouseX < inputBoxX + inputBoxWidth && mouseY > inputBoxY && mouseY < inputBoxY + inputBoxHeight) { // User clicked inside the text box, set focus focused = true;

// Calculate cursor position based on the click
float clickX = mouseX - (inputBoxX + textOffset); // X position within the text box
float textWidthUpToCursor = 0;
int newPosition = 0; // Default to start of the text

// Iterate through each character to find where the click occurred
for (int i = 0; i <= inputText.length(); i++) {
  // Update the text width up to the cursor after each character
  if (i > 0) {
    textWidthUpToCursor += textWidth(inputText.charAt(i - 1));
  }
  // Check if the accumulated width surpasses the click position
  if (textWidthUpToCursor > clickX) {
    newPosition = i - 1;
    break;
  }
  // If the click is beyond the last character, set the cursor at the end
  if (i == inputText.length()) {
    newPosition = inputText.length();
  }
}
cursorPosition = newPosition; // Update the cursor position

} else { // Click outside the text box, remove focus focused = false; } }

void keyPressed() { if (!focused) return;

if (key == ENTER || key == RETURN) { generateRandomOutputs(); sendOscMessage(); inputText = ""; // Clear the input text after sending cursorPosition = 0; } else if (key == BACKSPACE) { if (cursorPosition > 0 && inputText.length() > 0) { inputText = inputText.substring(0, cursorPosition - 1) + inputText.substring(cursorPosition); cursorPosition—; } } else if (key == DELETE) { if (cursorPosition < inputText.length()) { inputText = inputText.substring(0, cursorPosition) + inputText.substring(cursorPosition + 1); } } else if (key == LEFT) { if (cursorPosition > 0) cursorPosition—; } else if (key == RIGHT) { if (cursorPosition < inputText.length()) cursorPosition++; } else if (key >= 32 && key <= 126) { // Printable characters inputText = inputText.substring(0, cursorPosition) + key + inputText.substring(cursorPosition); cursorPosition++; } }

void generateRandomOutputs() { int baseSeed = inputText.length() + inputText.chars().sum(); randomSeed(baseSeed); // Resetting random seed with the base seed random(0, 101); // Discard the first result

for (int i = 0; i < outputValues.length; i++) { outputValues[i] = int(random(0, 101)); // Generate random numbers between 0 and 100 } }

void sendOscMessage() { if (outputValues.length == 4) { OscMessage msg = new OscMessage(“/randomValues”); for (int value : outputValues) { msg.add(value); } oscP5.send(msg, touchDesignerAddress); println(“Sent OSC message with random values: ” + outputValues[0] + ”, ” + outputValues[1] + ”, ” + outputValues[2] + ”, ” + outputValues[3]); } else { println(“Error: Incorrect number of output values. Expected 4 values.”); } }

ChatGPT

Your Processing script is designed to interact with TouchDesigner via OSC messaging, featuring a user interface for text input and displaying randomized output values. Here are a few things I noticed and some potential improvements you might consider:

Observations

1. User Interface Interaction:

   • You have a text input box and output boxes for displaying values. These interact dynamically based on user input and cursor interactions.

2. OSC Communication:

   • The script sends data to TouchDesigner, which can be used to drive visualizations or other interactions within TouchDesigner.

3. Random Output Generation:

   • The random values are seeded based on the input text, which is a neat feature for creating deterministic yet seemingly random outputs based on user input.

Suggestions for Improvement

1. Input Validation:

   • You might want to add some form of input validation or handling to ensure that the input text is appropriate for generating outputs or doesn’t exceed expected limits.

2. Enhanced User Feedback:

   • Consider adding visual or textual feedback when OSC messages are sent or when the user interacts with the input box (like highlighting or messages indicating successful data transmission).

3. Flexibility in OSC Message Configuration:

   • Allowing some configuration in how OSC messages are constructed and sent (e.g., customizing the OSC address or payload format from the UI) could make the script more flexible for different types of projects or user needs.

4. Error Handling:

   • Implementing error handling, particularly around OSC message sending and reception, can help in maintaining stable interaction, especially in live performance or installation settings.

5. UI Enhancements:

   • Enhancing the graphical user interface, such as using colors, icons, or different fonts, could improve the user experience and make the application more engaging.

6. Documentation and Help:

   • Adding in-line help or documentation accessible from the UI can assist users in understanding how to use the application effectively.

If you need any specific help with coding these enhancements or have other questions about your project, feel free to ask!

You

Thanks for your suggestions but first I need to take the 4 random numbers which are successful being displayed in the OSC IN node and then the Chop To DAT node in touch designer and use these numbers to change the index of a switch node. My current setup is the code below please change it accordingly:

def onTableChange(dat): chop_to_dat = op(‘chopto3’)

# Diagnostic output to check the raw data
print("Current DAT States:")
for col_index in range(chop_to_dat.numCols):
    col_value = chop_to_dat[0, col_index].val if chop_to_dat[0, col_index] is not None else 'None'
    print(f"Column {col_index}: {col_value}")

# Assuming the random number is in the first column
random_number = int(chop_to_dat[0, 0].val) if chop_to_dat[0, 0] is not None else 0
print("Random Number Received:", random_number)

# Set the switch index based on the random number
if 0 <= random_number <= 3:
    print(f"Switching to index {random_number}")
    op('switch1').par.index = random_number
else:
    print("Received number out of expected range, resetting index")
    op('switch1').par.index = 0  # Reset index or set to default view

ChatGPT

Your current TouchDesigner script in Python listens for changes in a DAT table, which it uses to modify the index of a switch node based on the values received from the OSC message sent by Processing. To adapt your script to use the four random numbers received from Processing to adjust the switch node, you can update your function to handle all columns of the DAT and set the switch index accordingly.

Here is an updated version of your script that handles multiple values, assuming each column of the chopto3 DAT corresponds to a separate switch index. This setup will allow you to dynamically control multiple switch nodes or parameters based on the incoming data:

def onTableChange(dat):
    chop_to_dat = op('chopto3')

    # Diagnostic output to check the raw data
    print("Current DAT States:")
    for col_index in range(chop_to_dat.numCols):
        col_value = chop_to_dat[0, col_index].val if chop_to_dat[0, col_index] is not None else 'None'
        print(f"Column {col_index}: {col_value}")

    # Iterate over all columns to set switch indices for multiple switches
    for col_index in range(min(chop_to_dat.numCols, 4)):  # Adjust 4 to the number of switches you have
        # Read the value from each column and convert it to an integer
        random_number = int(chop_to_dat[0, col_index].val) if chop_to_dat[0, col_index] is not None else 0
        print(f"Random Number Received from Column {col_index}: {random_number}")

        # Check if the switch corresponding to the current column exists
        switch_op_name = f'switch{col_index + 1}'
        if hasattr(op, switch_op_name):
            switch_op = op(switch_op_name)

            # Set the switch index based on the random number
            if 0 <= random_number <= 3:
                print(f"Setting {switch_op_name} to index {random_number}")
                switch_op.par.index = random_number
            else:
                print(f"Received number out of expected range for {switch_op_name}, resetting index")
                switch_op.par.index = 0  # Reset index or set to default view
        else:
            print(f"Switch {switch_op_name} not found")

Explanation:

1. Diagnostics: The script starts by printing the current state of the DAT to help with debugging.
2. Handling Multiple Columns: The script iterates over the columns of the DAT. The loop is limited to the minimum between the number of columns in the DAT and 4 (or the number of switches you have). This assumes that each column corresponds to a different switch.
3. Switch Existence Check: Before trying to set the index of a switch, it checks if the switch operator exists. This prevents errors if you have fewer switches than columns.
4. Index Setting: It then sets the index of each switch based on the corresponding random number. It includes safety checks to ensure the number is within the expected range (0 to 3 in this case).

Adjustments Needed:

• Make sure that the switch operators (switch1, switch2, etc.) exist in your network.
• The indices are set based on random numbers being within the range [0, 3]. If your switch setup or ranges differ, adjust these accordingly.
• Ensure that the DAT paths (chopto3) match your actual setup in TouchDesigner.

This approach provides flexibility and robustness for dynamic setups in interactive or generative media installations. If you need more specific customization or face any issues implementing this, feel free to ask!

You

Ah okay sorry there’s been a misunderstanding. I want the switch index to be changed to the corresponding column based on whichever has the highest value. In the event that two values are the same pick one at random.

ChatGPT

To modify your script so that the index of a single switch node is controlled by the highest value across multiple columns in a DAT, and to randomly select between columns in the case of a tie, here’s how you can adjust your TouchDesigner Python script:

import random

def onTableChange(dat):
    chop_to_dat = op('chopto3')

    # Diagnostic output to check the raw data
    print("Current DAT States:")
    values = []
    for col_index in range(chop_to_dat.numCols):
        col_value = float(chop_to_dat[0, col_index].val) if chop_to_dat[0, col_index] is not None else -1.0
        values.append(col_value)
        print(f"Column {col_index}: {col_value}")

    # Determine the highest value and corresponding index
    max_value = max(values)
    if max_value == -1:
        print("No valid data received, resetting index")
        op('switch1').par.index = 0
        return

    # Find all indices where the value equals the max value
    max_indices = [index for index, value in enumerate(values) if value == max_value]

    # Select a random index from those that have the max value
    selected_index = random.choice(max_indices)
    print(f"Selected index {selected_index} with value {max_value}")

    # Set the switch index based on the selected random index
    op('switch1').par.index = selected_index

Explanation of Changes:

1. Data Collection and Display:

   • The script first prints out the values of all columns. It collects these values into a list for easy comparison.
   • Values are converted to floats, ensuring compatibility with various numeric formats.

2. Finding the Highest Value:

   • The script finds the maximum value among the collected column values. If no valid data is received (all values are -1, a placeholder for “None”), it resets the switch index to 0.

3. Handling Ties:

   • If multiple columns have the maximum value, all such indices are collected into a list (max_indices).
   • One index is randomly selected from this list to handle ties randomly.

4. Setting the Switch Index:

   • The randomly chosen index from among the tied or singular maximum value indices is then used to set the switch’s index.

This script should efficiently manage the dynamic control of a switch node based on the highest values coming from an OSC interaction via Processing. It adds robustness in handling ties and ensures the interaction remains deterministic yet unpredictable when multiple maximum values are present. If you need any further modifications or explanations, feel free to ask!

You

Okay I now need to complicate things a bit. After an osc signal is sent the switch should change index. Wait for 2 seconds. And then return to index 0. Therefore I want to remap the 0,1,2,3 columns of the ‘CHOP TO’ node to index’s 1,2,3,4 of the switch

ChatGPT

To modify your script to handle the requirement where the switch changes to an index based on the maximum column value from a CHOP TO DAT node, waits for 2 seconds, and then returns to index 0, and also to remap the column indices (0, 1, 2, 3) to switch indices (1, 2, 3, 4), you will need to incorporate some timed actions. This can be achieved using a combination of Python scripting and possibly utilizing the run() function or a timerCHOP in TouchDesigner for the delay.

Here is an updated version of your script to achieve this:

import random

def onTableChange(dat):
    chop_to_dat = op('chopto3')

    # Diagnostic output to check the raw data
    print("Current DAT States:")
    values = []
    for col_index in range(chop_to_dat.numCols):
        col_value = float(chop_to_dat[0, col_index].val) if chop_to_dat[0, col_index] is not None else -1.0
        values.append(col_value)
        print(f"Column {col_index}: {col_value}")

    # Determine the highest value and corresponding index
    max_value = max(values)
    if max_value == -1:
        print("No valid data received, resetting index")
        op('switch1').par.index = 0
        return

    # Find all indices where the value equals the max value
    max_indices = [index for index, value in enumerate(values) if value == max_value]

    # Select a random index from those that have the max value and remap the index for the switch
    selected_index = random.choice(max_indices) + 1  # Add 1 to remap indices to 1, 2, 3, 4
    print(f"Selected index {selected_index} with value {max_value}")

    # Set the switch index based on the selected random index and schedule reset
    op('switch1').par.index = selected_index
    # Schedule to reset the index after 2 seconds
    run("op('switch1').par.index = 0", delayFrames = int(2 * me.time.rate))

Key Changes and Considerations:

1. Index Remapping:

   • After selecting the maximum index, it adds 1 to the index before applying it to the switch. This remaps the column indices (0, 1, 2, 3) to switch indices (1, 2, 3, 4).

2. Timing Delay:

   • The run() function is used to schedule another script to run after a delay, specified in frames. Assuming your project is running at a standard frame rate (e.g., 30 fps), you can calculate the delay in frames. If your project has a different rate, adjust me.time.rate accordingly.
   • This line run("op('switch1').par.index = 0", delayFrames = int(2 * me.time.rate)) schedules the reset of the switch index to 0 after 2 seconds.

Using Timer CHOP (Alternative Method):

If you prefer, you can use a timerCHOP to handle the delay and reset action, which might be more visual and easier to manage in complex networks:

• Setup: Configure a timerCHOP to start when the switch index changes and to last for 2 seconds.
• Callbacks: Use the Timer callbacks to reset the index when the timer completes.

This script modification should fulfill your requirement to dynamically control a switch based on data, with a timed return to a default state, enhancing your interactive or installation setup in TouchDesigner. If you encounter any issues or need further customization, feel free to ask!

You

The delay and return to 0 works. But now it always changes to index 1. I still need it to change index based on whichever column in the DAT has the highest value

ChatGPT

Let’s address the issue where the switch is always changing to index 1 despite intending to change according to the highest value in the columns of the DAT. We’ll review the logic and correct the remapping so that the selected index properly reflects the column with the highest value.

Here’s an updated version of the script that ensures the switch changes to the index corresponding to the column with the highest value:

import random

def onTableChange(dat):
    chop_to_dat = op('chopto3')

    # Diagnostic output to check the raw data
    print("Current DAT States:")
    values = []
    for col_index in range(chop_to_dat.numCols):
        col_value = float(chop_to_dat[0, col_index].val) if chop_to_dat[0, col_index] is not None else -1.0
        values.append(col_value)
        print(f"Column {col_index}: {col_value}")

    # Determine the highest value and corresponding index
    max_value = max(values)
    if max_value == -1:
        print("No valid data received, resetting index")
        op('switch1').par.index = 0
        return

    # Find all indices where the value equals the max value
    max_indices = [index for index, value in enumerate(values) if value == max_value]

    # Select a random index from those that have the max value
    selected_index = random.choice(max_indices)
    print(f"Selected index {selected_index} with value {max_value}")

    # Set the switch index based on the selected random index
    # Adding 1 to remap indices from 0-3 to 1-4
    remapped_index = selected_index + 1
    print(f"Setting switch to index {remapped_index}")
    op('switch1').par.index = remapped_index

    # Schedule to reset the index after 2 seconds
    run("op('switch1').par.index = 0", delayFrames = int(2 * me.time.rate))

Key Changes and Verification Steps:

1. Verification of Index Remapping:

   • This script ensures that after determining the highest column, it correctly remaps the index from 0-3 to 1-4. The remapping occurs right before setting the switch index, making it easier to verify and understand.

2. Debug Outputs:

   • Additional print statements are included to provide clear feedback on which index is selected and how it is remapped. This helps in debugging if the values don’t seem to be setting correctly.

3. Scheduled Reset:

   • The reset functionality continues as previously described, using the run() function to revert the switch index to 0 after a 2-second delay.

Testing:

• Simulate Data Changes: Manually adjust values in the chop_to_dat to simulate receiving different highest values and observe the console output and switch behavior to confirm that the highest value’s corresponding index is selected and remapped correctly.

• Edge Cases: Test scenarios where multiple columns have the same maximum value to ensure that the random selection among the highest values is functioning as expected.

This update should solve the problem of the switch always changing to index 1, and ensure that it dynamically responds to the highest value in your incoming data from Processing. If there are further issues or if additional functionality is needed, feel free to reach out!

You

The previous script worked. I needed to change:

chop_to_dat = op(‘chopto3)

to

chop_to_dat = op(‘chopto4’)

ChatGPT

Great to hear that the previous script worked for you once adjusted to the correct operator! Switching the reference from op('chopto3') to op('chopto4') means you’re now pointing to the right CHOP where your data is coming from. This kind of adjustment is common when configuring scripts to match specific setups in TouchDesigner networks, as operator names and configurations can vary widely.

If you need further modifications or if you’re looking to expand functionality or streamline processes within your TouchDesigner project, feel free to ask for more assistance or tips. Happy designing!