Automatic OSC Value Sending

2024-07-18 07:56 UTC gpt-4o Open in ChatGPT ↗

You

Please ammend this script to automatically send the osc values every 10 seconds, randomly changing the values each time:

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(“/newMessage”, 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

ChatGPT

To automatically send the OSC values every 10 seconds and randomly change the values each time, we can make use of the generate_random_distribution function inside a loop with a 10-second sleep interval. Below is the amended script:

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'}

# 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 to send random OSC values every 10 seconds
while True:
    # Generate a random distribution
    random_distribution = generate_random_distribution(categories)
    matched_words = {category: [] for category in categories}  # Empty matched words since it's random

    # Plot and send the random distribution
    plot_emotion_distribution(random_distribution, categories, True, matched_words)
    send_osc(random_distribution, matched_words)

    print("Emotion Distribution (Random Generation):")
    for category, value in random_distribution.items():
        print(f"{category}: {value:.2f}%")

    time.sleep(10)  # Wait for 10 seconds before repeating

This script now generates a new random distribution of values every 10 seconds and sends these values via OSC, updating the plot accordingly.

You

Can we now ammend this to also send a word response. Choose to send the word coresponding to the highest category value eg. either: angel, hero, feminist or rebel

ChatGPT

Sure, we can amend the script to send the word corresponding to the highest category value along with the values. Below is the updated script with the added functionality:

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'}

# 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):
    highest_category = max(counts, key=counts.get)  # Get the category with the highest value

    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("/highest_category", highest_category)  # Send the highest category word

# Main loop to send random OSC values every 10 seconds
while True:
    # Generate a random distribution
    random_distribution = generate_random_distribution(categories)
    matched_words = {category: [] for category in categories}  # Empty matched words since it's random

    # Plot and send the random distribution
    plot_emotion_distribution(random_distribution, categories, True, matched_words)
    send_osc(random_distribution, matched_words)

    print("Emotion Distribution (Random Generation):")
    for category, value in random_distribution.items():
        print(f"{category}: {value:.2f}%")

    time.sleep(10)  # Wait for 10 seconds before repeating

This updated script now identifies the category with the highest value in the random distribution and sends that category as a word response via OSC. The key change is the addition of the line:

osc_client.send_message("/highest_category", highest_category)  # Send the highest category word

You

Please also print the word beign sent via osc as ‘word response: ’

ChatGPT

Sure, I have added the print statement to display the word being sent via OSC. Below is the updated script:

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'}

# 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):
    highest_category = max(counts, key=counts.get)  # Get the category with the highest value

    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("/highest_category", highest_category)  # Send the highest category word
    print(f"Word response: {highest_category}")  # Print the word response

# Main loop to send random OSC values every 10 seconds
while True:
    # Generate a random distribution
    random_distribution = generate_random_distribution(categories)
    matched_words = {category: [] for category in categories}  # Empty matched words since it's random

    # Plot and send the random distribution
    plot_emotion_distribution(random_distribution, categories, True, matched_words)
    send_osc(random_distribution, matched_words)

    print("Emotion Distribution (Random Generation):")
    for category, value in random_distribution.items():
        print(f"{category}: {value:.2f}%")

    time.sleep(10)  # Wait for 10 seconds before repeating

Now, the script prints the word corresponding to the highest category value being sent via OSC as Word response: <category>.

You

Touch designer in expecting ‘/wordResponse’ for the osc in message, please ammend accordingly

ChatGPT

Sure, I have updated the script to send the highest category value using the OSC address /wordResponse. Here is the amended script:

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'}

# 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):
    highest_category = max(counts, key=counts.get)  # Get the category with the highest value

    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("/wordResponse", highest_category)  # Send the highest category word
    print(f"Word response: {highest_category}")  # Print the word response

# Main loop to send random OSC values every 10 seconds
while True:
    # Generate a random distribution
    random_distribution = generate_random_distribution(categories)
    matched_words = {category: [] for category in categories}  # Empty matched words since it's random

    # Plot and send the random distribution
    plot_emotion_distribution(random_distribution, categories, True, matched_words)
    send_osc(random_distribution, matched_words)

    print("Emotion Distribution (Random Generation):")
    for category, value in random_distribution.items():
        print(f"{category}: {value:.2f}%")

    time.sleep(10)  # Wait for 10 seconds before repeating

This updated script now sends the highest category word using the OSC address /wordResponse, which should be compatible with TouchDesigner.