OSC Signal with Message Counter

2024-05-29 11:54 UTC gpt-4o Open in ChatGPT ↗

You

I’m using this script to send osc signals to touch designer.

import matplotlib.pyplot as plt import numpy as np import string import time from pythonosc import udp_client

Paths to the emotion mapping file and input text file

mapping_file_path = ‘C:/Users/Chris/PycharmProjects/SentimentAnalysis_Test/emotions.txt’ input_text_file_path = ‘C:/Users/Chris/PycharmProjects/SentimentAnalysis_Test/read.txt’

Defined categories

categories = [‘angel’, ‘hero’, ‘feminist’, ‘rebel’]

Color mapping for categories

color_mapping = {‘angel’: ‘yellow’, ‘hero’: ‘darkblue’, ‘feminist’: ‘green’, ‘rebel’: ‘red’}

Variable to track the previous text

previous_text = ""

Variable to store the last distribution

last_distribution = None

OSC client setup

osc_client = udp_client.SimpleUDPClient(“127.0.0.1”, 9000)

Function to load emotion mappings from a file

def load_emotion_mapping(file_path): mapping = {} with open(file_path, ‘r’) as f: for line in f: parts = line.strip().split(’:’) if len(parts) == 2: word, category = parts mapping[word.strip().lower()] = category.strip().lower() return mapping

Function to load the input text from a file

def load_input_text(file_path): with open(file_path, ‘r’) as f: return f.read()

Function to process the text and count emotions per category

def count_emotions(text, mapping, categories): # Remove punctuation from text text = text.translate(str.maketrans(”, ”, string.punctuation)) text_words = text.lower().split() counts = {category: 0 for category in categories} matched_words = {category: [] for category in categories} matched = False

for word in text_words:
    if word in mapping:
        category = mapping[word]
        counts[category] += 1
        matched_words[category].append(word)
        matched = True

return counts, matched, matched_words

Random distribution generator

def generate_random_distribution(categories): random_distribution = np.random.dirichlet(np.ones(len(categories)), size=1)[0] return {categories[i]: random_distribution[i] * 100 for i in range(len(categories))}

Plotting function with adjusted annotation position

def plot_emotion_distribution(counts, categories, no_matches, matched_words): plt.clf() # Clear the previous plot values = [counts.get(category, 0) for category in categories] colors = [color_mapping[category] for category in categories] # Assigning colors based on category

plt.bar(categories, values, color=colors)  # Using assigned colors
plt.xlabel('Emotion Category')
plt.ylabel('Percentage')
plt.title('Emotion Distribution')
plt.ylim(0, max(values) + 20 + 2*max(len(words) for words in matched_words.values()))  # Provide extra vertical space above bars

# Add the annotation for no matches if randomly generated
if no_matches:
    plt.text(len(categories) / 2, max(values) + 10, '0% Match. Generating Random Distribution.', fontsize=10,
             color='red', ha='center')

# Add matched words above each column
for i, category in enumerate(categories):
    words = matched_words[category]
    for j, word in enumerate(words):
        plt.text(i, values[i] + 2 + j * 2, word, fontsize=8, color='black', ha='center')  # Increased spacing

plt.pause(0.1)  # Pause to update the plot

Function to send the emotion distribution and matched words via OSC

def send_osc(counts, matched_words): for category, value in counts.items(): osc_client.send_message(f”/{category}”, value) words_message = ’, ‘.join(matched_words[category]) osc_client.send_message(f”/{category}_words”, words_message if words_message else ” “)

Main loop

while True: # Load the emotion mapping from the file emotion_mapping = load_emotion_mapping(mapping_file_path)

# Load the input text from the file
text = load_input_text(input_text_file_path)

# Check if the text has changed
text_changed = text != previous_text

# Check and count emotions
counts, matched, matched_words = count_emotions(text, emotion_mapping, categories)

# If there are no matched words
if not matched:
    # Generate random distribution only if the text has changed or there is no previous random distribution
    if text_changed or last_distribution is None:
        last_distribution = generate_random_distribution(categories)
        print("Emotion Distribution (Random Generation):")
        for category, value in last_distribution.items():
            print(f"{category}: {value:.2f}%")
        plot_emotion_distribution(last_distribution, categories, True, matched_words)
        send_osc(last_distribution, matched_words)
    else:
        # Re-use the last random distribution if the text hasn't changed
        print("Emotion Distribution (Re-using Random Generation):")
        for category, value in last_distribution.items():
            print(f"{category}: {value:.2f}%")
        plot_emotion_distribution(last_distribution, categories, True, matched_words)
        send_osc(last_distribution, matched_words)
else:
    # Normalize percentages if words matched
    total_count = sum(counts.values())
    if total_count > 0:
        counts = {k: (v / total_count) * 100 for k, v in counts.items()}
    print("Emotion Distribution:")
    for category, value in counts.items():
        print(f"{category}: {value:.2f}%")
    plot_emotion_distribution(counts, categories, False, matched_words)
    send_osc(counts, matched_words)
    last_distribution = counts

# Update the previous text to the current text
previous_text = text

time.sleep(1)  # Wait for 1 second before repeating

I want to add an additional channel ‘new message’ which counts up everytime a new message is sent

ChatGPT

To add an additional channel ‘new_message’ that increments each time a new message is sent, you can modify the script to include a counter for new messages. Here’s how you can integrate this feature into your existing code:

1. Initialize a counter for the new messages.
2. Increment the counter each time the script sends out a new message.
3. Send the counter value via OSC to the new_message channel.

Here’s the updated script with these changes:

import matplotlib.pyplot as plt
import numpy as np
import string
import time
from pythonosc import udp_client

# Paths to the emotion mapping file and input text file
mapping_file_path = 'C:/Users/Chris/PycharmProjects/SentimentAnalysis_Test/emotions.txt'
input_text_file_path = 'C:/Users/Chris/PycharmProjects/SentimentAnalysis_Test/read.txt'

# Defined categories
categories = ['angel', 'hero', 'feminist', 'rebel']

# Color mapping for categories
color_mapping = {'angel': 'yellow', 'hero': 'darkblue', 'feminist': 'green', 'rebel': 'red'}

# Variable to track the previous text
previous_text = ""

# Variable to store the last distribution
last_distribution = None

# Variable to track the number of new messages
new_message_count = 0

# OSC client setup
osc_client = udp_client.SimpleUDPClient("127.0.0.1", 9000)

# Function to load emotion mappings from a file
def load_emotion_mapping(file_path):
    mapping = {}
    with open(file_path, 'r') as f:
        for line in f:
            parts = line.strip().split(':')
            if len(parts) == 2:
                word, category = parts
                mapping[word.strip().lower()] = category.strip().lower()
    return mapping

# Function to load the input text from a file
def load_input_text(file_path):
    with open(file_path, 'r') as f:
        return f.read()

# Function to process the text and count emotions per category
def count_emotions(text, mapping, categories):
    # Remove punctuation from text
    text = text.translate(str.maketrans('', '', string.punctuation))
    text_words = text.lower().split()
    counts = {category: 0 for category in categories}
    matched_words = {category: [] for category in categories}
    matched = False

    for word in text_words:
        if word in mapping:
            category = mapping[word]
            counts[category] += 1
            matched_words[category].append(word)
            matched = True

    return counts, matched, matched_words

# Random distribution generator
def generate_random_distribution(categories):
    random_distribution = np.random.dirichlet(np.ones(len(categories)), size=1)[0]
    return {categories[i]: random_distribution[i] * 100 for i in range(len(categories))}

# Plotting function with adjusted annotation position
def plot_emotion_distribution(counts, categories, no_matches, matched_words):
    plt.clf()  # Clear the previous plot
    values = [counts.get(category, 0) for category in categories]
    colors = [color_mapping[category] for category in categories]  # Assigning colors based on category

    plt.bar(categories, values, color=colors)  # Using assigned colors
    plt.xlabel('Emotion Category')
    plt.ylabel('Percentage')
    plt.title('Emotion Distribution')
    plt.ylim(0, max(values) + 20 + 2*max(len(words) for words in matched_words.values()))  # Provide extra vertical space above bars

    # Add the annotation for no matches if randomly generated
    if no_matches:
        plt.text(len(categories) / 2, max(values) + 10, '0% Match. Generating Random Distribution.', fontsize=10,
                 color='red', ha='center')

    # Add matched words above each column
    for i, category in enumerate(categories):
        words = matched_words[category]
        for j, word in enumerate(words):
            plt.text(i, values[i] + 2 + j * 2, word, fontsize=8, color='black', ha='center')  # Increased spacing

    plt.pause(0.1)  # Pause to update the plot

# Function to send the emotion distribution and matched words via OSC
def send_osc(counts, matched_words, new_message_count):
    for category, value in counts.items():
        osc_client.send_message(f"/{category}", value)
        words_message = ', '.join(matched_words[category])
        osc_client.send_message(f"/{category}_words", words_message if words_message else " ")
    osc_client.send_message("/new_message", new_message_count)

# Main loop
while True:
    # Load the emotion mapping from the file
    emotion_mapping = load_emotion_mapping(mapping_file_path)

    # Load the input text from the file
    text = load_input_text(input_text_file_path)

    # Check if the text has changed
    text_changed = text != previous_text

    # Check and count emotions
    counts, matched, matched_words = count_emotions(text, emotion_mapping, categories)

    # If there are no matched words
    if not matched:
        # Generate random distribution only if the text has changed or there is no previous random distribution
        if text_changed or last_distribution is None:
            last_distribution = generate_random_distribution(categories)
            print("Emotion Distribution (Random Generation):")
            for category, value in last_distribution.items():
                print(f"{category}: {value:.2f}%")
            plot_emotion_distribution(last_distribution, categories, True, matched_words)
            send_osc(last_distribution, matched_words, new_message_count)
        else:
            # Re-use the last random distribution if the text hasn't changed
            print("Emotion Distribution (Re-using Random Generation):")
            for category, value in last_distribution.items():
                print(f"{category}: {value:.2f}%")
            plot_emotion_distribution(last_distribution, categories, True, matched_words)
            send_osc(last_distribution, matched_words, new_message_count)
    else:
        # Normalize percentages if words matched
        total_count = sum(counts.values())
        if total_count > 0:
            counts = {k: (v / total_count) * 100 for k, v in counts.items()}
        print("Emotion Distribution:")
        for category, value in counts.items():

You

How do i get this new message counter to display as an osc channel in my oscin chop

ChatGPT

To display the new_message counter as an OSC channel in your OSCin CHOP in TouchDesigner, you need to ensure that TouchDesigner is properly set up to receive OSC messages and that the script is sending the new_message count as an OSC message. Here’s how to do it step-by-step:

1. Modify the Python Script

The provided script already includes the logic to send the new_message count. Ensure the following part is present and correctly implemented in the send_osc function:

def send_osc(counts, matched_words, new_message_count):
    for category, value in counts.items():
        osc_client.send_message(f"/{category}", value)
        words_message = ', '.join(matched_words[category])
        osc_client.send_message(f"/{category}_words", words_message if words_message else " ")
    osc_client.send_message("/new_message", new_message_count)

Ensure the new_message_count is being incremented in the main loop each time a new message is processed:

# Main loop
while True:
    # Load the emotion mapping from the file
    emotion_mapping = load_emotion_mapping(mapping_file_path)

    # Load the input text from the file
    text = load_input_text(input_text_file_path)

    # Check if the text has changed
    text_changed = text != previous_text

    # Increment new message counter if text has changed
    if text_changed:
        new_message_count += 1

    # Check and count emotions
    counts, matched, matched_words = count_emotions(text, emotion_mapping, categories)

    # If there are no matched words
    if not matched:
        # Generate random distribution only if the text has changed or there is no previous random distribution
        if text_changed or last_distribution is None:
            last_distribution = generate_random_distribution(categories)
            print("Emotion Distribution (Random Generation):")
            for category, value in last_distribution.items():
                print(f"{category}: {value:.2f}%")
            plot_emotion_distribution(last_distribution, categories, True, matched_words)
            send_osc(last_distribution, matched_words, new_message_count)
        else:
            # Re-use the last random distribution if the text hasn't changed
            print("Emotion Distribution (Re-using Random Generation):")
            for category, value in last_distribution.items():
                print(f"{category}: {value:.2f}%")
            plot_emotion_distribution(last_distribution, categories, True, matched_words)
            send_osc(last_distribution, matched_words, new_message_count)
    else:
        # Normalize percentages if words matched
        total_count = sum(counts.values())
        if total_count > 0:
            counts = {k: (v / total_count) * 100 for k, v in counts.items()}
        print("Emotion Distribution:")
        for category, value in counts.items():
            print(f"{category}: {value:.2f}%")
        plot_emotion_distribution(counts, categories, False, matched_words)
        send_osc(counts, matched_words, new_message_count)
        last_distribution = counts

    # Update the previous text to the current text
    previous_text = text

    time.sleep(1)  # Wait for 1 second before repeating

2. Setup TouchDesigner to Receive OSC

1. Open TouchDesigner and create a new project.

2. Add an OSCin CHOP to the network:

   • Press Tab to open the OP Create Dialog.
   • Navigate to CHOP and select OSCin.
   • Place the OSCin CHOP in your network.

3. Configure the OSCin CHOP:

   • Set the Network Address to 127.0.0.1 (if running locally).
   • Set the Port to 9000 (this should match the port used in the Python script).

4. Monitor Incoming Channels:

   • The OSCin CHOP should automatically display all incoming OSC messages as channels.
   • You should see channels like /angel, /hero, /feminist, /rebel, /new_message, etc.

5. Debugging and Visualization:

   • Add a Trail CHOP or Null CHOP connected to the OSCin CHOP to visualize the values.
   • Ensure that you see the new_message channel and that its value increments as expected when new messages are processed.

By following these steps, you should be able to display the new_message counter as an OSC channel in TouchDesigner, and it will increment each time a new message is sent from your Python script.

You

please integrate this into the previous code

ChatGPT

Certainly! Here is the fully integrated script with the new_message counter implemented. The script will increment the new_message_count each time a new message is processed and send this count via OSC to the new_message channel.

import matplotlib.pyplot as plt
import numpy as np
import string
import time
from pythonosc import udp_client

# Paths to the emotion mapping file and input text file
mapping_file_path = 'C:/Users/Chris/PycharmProjects/SentimentAnalysis_Test/emotions.txt'
input_text_file_path = 'C:/Users/Chris/PycharmProjects/SentimentAnalysis_Test/read.txt'

# Defined categories
categories = ['angel', 'hero', 'feminist', 'rebel']

# Color mapping for categories
color_mapping = {'angel': 'yellow', 'hero': 'darkblue', 'feminist': 'green', 'rebel': 'red'}

# Variable to track the previous text
previous_text = ""

# Variable to store the last distribution
last_distribution = None

# Variable to track the number of new messages
new_message_count = 0

# OSC client setup
osc_client = udp_client.SimpleUDPClient("127.0.0.1", 9000)

# Function to load emotion mappings from a file
def load_emotion_mapping(file_path):
    mapping = {}
    with open(file_path, 'r') as f:
        for line in f:
            parts = line.strip().split(':')
            if len(parts) == 2:
                word, category = parts
                mapping[word.strip().lower()] = category.strip().lower()
    return mapping

# Function to load the input text from a file
def load_input_text(file_path):
    with open(file_path, 'r') as f:
        return f.read()

# Function to process the text and count emotions per category
def count_emotions(text, mapping, categories):
    # Remove punctuation from text
    text = text.translate(str.maketrans('', '', string.punctuation))
    text_words = text.lower().split()
    counts = {category: 0 for category in categories}
    matched_words = {category: [] for category in categories}
    matched = False

    for word in text_words:
        if word in mapping:
            category = mapping[word]
            counts[category] += 1
            matched_words[category].append(word)
            matched = True

    return counts, matched, matched_words

# Random distribution generator
def generate_random_distribution(categories):
    random_distribution = np.random.dirichlet(np.ones(len(categories)), size=1)[0]
    return {categories[i]: random_distribution[i] * 100 for i in range(len(categories))}

# Plotting function with adjusted annotation position
def plot_emotion_distribution(counts, categories, no_matches, matched_words):
    plt.clf()  # Clear the previous plot
    values = [counts.get(category, 0) for category in categories]
    colors = [color_mapping[category] for category in categories]  # Assigning colors based on category

    plt.bar(categories, values, color=colors)  # Using assigned colors
    plt.xlabel('Emotion Category')
    plt.ylabel('Percentage')
    plt.title('Emotion Distribution')
    plt.ylim(0, max(values) + 20 + 2*max(len(words) for words in matched_words.values()))  # Provide extra vertical space above bars

    # Add the annotation for no matches if randomly generated
    if no_matches:
        plt.text(len(categories) / 2, max(values) + 10, '0% Match. Generating Random Distribution.', fontsize=10,
                 color='red', ha='center')

    # Add matched words above each column
    for i, category in enumerate(categories):
        words = matched_words[category]
        for j, word in enumerate(words):
            plt.text(i, values[i] + 2 + j * 2, word, fontsize=8, color='black', ha='center')  # Increased spacing

    plt.pause(0.1)  # Pause to update the plot

# Function to send the emotion distribution and matched words via OSC
def send_osc(counts, matched_words, new_message_count):
    for category, value in counts.items():
        osc_client.send_message(f"/{category}", value)
        words_message = ', '.join(matched_words[category])
        osc_client.send_message(f"/{category}_words", words_message if words_message else " ")
    osc_client.send_message("/new_message", new_message_count)

# Main loop
while True:
    # Load the emotion mapping from the file
    emotion_mapping = load_emotion_mapping(mapping_file_path)

    # Load the input text from the file
    text = load_input_text(input_text_file_path)

    # Check if the text has changed
    text_changed = text != previous_text

    # Increment new message counter if text has changed
    if text_changed:
        new_message_count += 1

    # Check and count emotions
    counts, matched, matched_words = count_emotions(text, emotion_mapping, categories)

    # If there are no matched words
    if not matched:
        # Generate random distribution only if the text has changed or there is no previous random distribution
        if text_changed or last_distribution is None:
            last_distribution = generate_random_distribution(categories)
            print("Emotion Distribution (Random Generation):")
            for category, value in last_distribution.items():
                print(f"{category}: {value:.2f}%")
            plot_emotion_distribution(last_distribution, categories, True, matched_words)
            send_osc(last_distribution, matched_words, new_message_count)
        else:
            # Re-use the last random distribution if the text hasn't changed
            print("Emotion Distribution (Re-using Random Generation):")
            for category, value in last_distribution.items():
                print(f"{category}: {value:.2f}%")
            plot_emotion_distribution(last_distribution, categories, True, matched_words)
            send_osc(last_distribution, matched_words, new_message_count)
    else:
        # Normalize percentages if words matched
        total_count = sum(counts.values())
        if total_count > 0:
            counts = {k: (v / total_count) * 100 for k, v in counts.items()}
        print("Emotion Distribution:")
        for category, value in counts.items():
            print(f"{category}: {value:.2f}%")
        plot_emotion_distribution(counts, categories, False, matched_words)
        send_osc(counts, matched_words, new_message_count)
        last_distribution = counts

    # Update the previous text to the current text
    previous_text = text

    time.sleep(1)  # Wait for 1 second before repeating

With this script, every time a new message is detected (when the input text changes), the new_message_count is incremented, and this count is sent via OSC to the /new_message channel. You can monitor this channel in TouchDesigner to see the count of new messages.

In TouchDesigner, make sure the OSCin CHOP is correctly set up to receive OSC messages on the specified IP address and port. You should see the new_message channel along with the other emotion category channels.