Count Words via OSC

2024-05-15 13:57 UTC gpt-4o Open in ChatGPT ↗

You

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)  # 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 next to the graph
for i, category in enumerate(categories):
    words = ', '.join(matched_words[category])
    plt.text(i, values[i] + 2, words, fontsize=8, color='black', ha='center', wrap=True)

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

Function to send the emotion distribution via OSC

def send_osc(counts): for category, value in counts.items(): osc_client.send_message(f”/{category}”, value)

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)
    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)
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)
    last_distribution = counts

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

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

This script is working well. I now need to also send the list of matched words into touchdesigner via osc and display them in a table

ChatGPT

To send the list of matched words via OSC to TouchDesigner, we need to modify the send_osc function to include the matched words. We’ll send each category’s matched words as a separate message. Below is the updated script with the necessary 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

# 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)  # 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 next to the graph
    for i, category in enumerate(categories):
        words = ', '.join(matched_words[category])
        plt.text(i, values[i] + 2, words, fontsize=8, color='black', ha='center', wrap=True)

    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)
        osc_client.send_message(f"/{category}_words", matched_words[category])

# 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

In this updated script:

• The send_osc function now also sends the matched words for each category.
• Each category’s matched words are sent as a message with the address /{category}_words.

In TouchDesigner, you can use the OSC In DAT to receive the messages and display them in a table. Make sure you set up the OSC In DAT to listen on port 9000, which matches the port used in the script.

You

This doesnt seem to be working. I’m getting ‘/rebel 40.24049’ and ‘/rebel words’ appearing in the oscin dat but all i want to see are the 4 categories as rows and then the columns should have the matched words. I also need the matched words to be displayed on the graph above each column

ChatGPT

I understand, you need the OSC messages to be structured so that the matched words are sent together in a way that can be easily displayed in TouchDesigner. Additionally, the graph needs to display the matched words above each column. Let’s adjust the script accordingly:

1. Modify the send_osc function to send a single OSC message containing all matched words for each category.
2. Adjust the plotting function to display the matched words above each column more clearly.

Here’s the revised 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'}

# 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)  # 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 = ', '.join(matched_words[category])
        plt.text(i, values[i] + 2, words, fontsize=8, color='black', ha='center', wrap=True)

    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)

# 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

TouchDesigner Setup:

1. OSC In DAT: Add an OSC In DAT, set the network address to 127.0.0.1 and the port to 9000.
2. Text DATs: Add Text DATs or Table DATs for each category to display the matched words.
3. DAT Execute: Use a DAT Execute to react to changes in the OSC In DAT and update the respective Text/Table DATs with the received matched words.

In TouchDesigner, you can parse the OSC messages to update the UI elements like tables. The structure of the messages should now be easier to handle, with each message containing a single string of comma-separated words for each category.

You

How do i connect the osc in dat to a text or table dat to display the words?

ChatGPT

To connect the OSC In DAT to a Text DAT or Table DAT in TouchDesigner to display the words, you can use a Python script within a DAT Execute DAT to update the content dynamically. Here’s a step-by-step guide on how to do this:

1. Add OSC In DAT:

   • Add an OSC In DAT to your project.
   • Set the network address to 127.0.0.1 and the port to 9000.

2. Add Table DATs:

   • Add a Table DAT for each category (angel, hero, feminist, rebel).
   • Optionally, rename these Table DATs to something meaningful like angel_table, hero_table, feminist_table, rebel_table.

3. Add DAT Execute DAT:

   • Add a DAT Execute DAT and connect it to the OSC In DAT.
   • This DAT Execute will run a script whenever there is a change in the OSC In DAT.

4. Configure the DAT Execute DAT:

   • In the DAT Execute DAT, write a script that will update the corresponding Table DATs based on the OSC messages.

Here’s an example script for the DAT Execute DAT:

def onTableChange(dat):
    # This function is called whenever the OSC In DAT is updated

    # Iterate through the rows of the OSC In DAT
    for row in dat.rows():
        address = row[0].val  # OSC address (e.g., '/angel_words')
        words = row[1].val  # OSC message content (e.g., 'word1, word2, word3')

        # Determine which category's table to update based on the address
        if address == '/angel_words':
            target_table = op('angel_table')
        elif address == '/hero_words':
            target_table = op('hero_table')
        elif address == '/feminist_words':
            target_table = op('feminist_table')
        elif address == '/rebel_words':
            target_table = op('rebel_table')
        else:
            continue  # Ignore unrecognized addresses

        # Update the target table with the words
        words_list = words.split(', ')  # Split the words into a list
        target_table.clear()  # Clear the current contents of the table

        # Fill the table with the new words
        for word in words_list:
            target_table.appendRow([word])

    return

def onTableRowChange(dat, rows):
    return

def onTableColChange(dat, cols):
    return

def onTableCellChange(dat, cells):
    return

def onPulse(par):
    return

5. Set the DAT Execute Script:

   • Copy the above script and paste it into the DAT Execute DAT script editor.
   • Ensure that the onTableChange function is enabled (checked).

6. Verify OSC Addresses and Messages:

   • Ensure your script sending OSC messages is using the correct addresses (e.g., /angel_words, /hero_words, etc.).
   • The OSC messages should contain the words as a single string, separated by commas.

Summary

• The OSC In DAT receives the OSC messages.
• The DAT Execute DAT listens for changes in the OSC In DAT.
• The script in the DAT Execute DAT updates the corresponding Table DAT with the received words.

This setup will dynamically update the Table DATs with the matched words based on the OSC messages. You can further customize the script and layout as needed for your project.

You

the dat exec is not sending to the coressponding tables.

index error: list index out of range

ChatGPT

It seems like the DAT Execute script is encountering an issue due to unexpected data structure or content in the OSC In DAT. Let’s ensure the script correctly handles the incoming OSC messages and properly updates the corresponding tables. We will add some debugging and checks to ensure the script works as intended.

Steps:

1. Verify OSC In DAT: Ensure the OSC messages are coming in the expected format. Each row should have two columns: the OSC address and the message content.

2. Update Script: Modify the script to include checks and debugging output to help identify issues.

Here’s the revised script for the DAT Execute DAT:

def onTableChange(dat):
    # This function is called whenever the OSC In DAT is updated
    # Print the incoming data for debugging
    print("OSC In DAT updated. Content:")
    print(dat.text())

    # Iterate through the rows of the OSC In DAT
    for row in dat.rows():
        # Ensure row has at least two columns to avoid index errors
        if len(row) < 2:
            continue

        address = row[0].val  # OSC address (e.g., '/angel_words')
        words = row[1].val  # OSC message content (e.g., 'word1, word2, word3')

        # Determine which category's table to update based on the address
        if address == '/angel_words':
            target_table = op('angel_table')
        elif address == '/hero_words':
            target_table = op('hero_table')
        elif address == '/feminist_words':
            target_table = op('feminist_table')
        elif address == '/rebel_words':
            target_table = op('rebel_table')
        else:
            print(f"Unrecognized OSC address: {address}")
            continue  # Ignore unrecognized addresses

        # Update the target table with the words
        words_list = words.split(', ')  # Split the words into a list
        target_table.clear()  # Clear the current contents of the table

        # Fill the table with the new words
        for word in words_list:
            target_table.appendRow([word])

    return

def onTableRowChange(dat, rows):
    return

def onTableColChange(dat, cols):
    return

def onTableCellChange(dat, cells):
    return

def onPulse(par):
    return

Setting Up TouchDesigner:

1. OSC In DAT: Add an OSC In DAT, set the network address to 127.0.0.1 and the port to 9000.
2. Table DATs: Add four Table DATs for each category and rename them to angel_table, hero_table, feminist_table, and rebel_table.
3. DAT Execute DAT: Add a DAT Execute DAT and connect it to the OSC In DAT.
   • Paste the updated script into the DAT Execute DAT script editor.
   • Enable the onTableChange function.

Debugging Tips:

• Check OSC Data: Use the print(dat.text()) line to see the contents of the OSC In DAT. This will help verify that the data is being received correctly.
• Print Statements: Use print statements to trace the flow of data and identify where things might be going wrong.
• Data Format: Ensure that each OSC message has the correct format with two columns: the address and the message content.

By following these steps and using the updated script, you should be able to dynamically update the Table DATs with the matched words based on the OSC messages. If the issue persists, the debugging output should provide more insight into what might be going wrong.

You

‘str’ object is not callable

ChatGPT

It seems like there might be an issue with the print(dat.text()) function or with the way the text method is being called. Let’s remove the problematic line and make sure the script works correctly without it. Additionally, I’ll add some debug print statements to help us identify where the issue might be occurring.

Here’s the updated script:

Updated Script

def onTableChange(dat):
    # This function is called whenever the OSC In DAT is updated
    # Debug: Print the incoming data for debugging
    print("OSC In DAT updated. Content:")
    for row in dat.rows():
        print([cell.val for cell in row])

    # Iterate through the rows of the OSC In DAT
    for row in dat.rows():
        # Ensure row has at least two columns to avoid index errors
        if len(row) < 2:
            continue

        address = row[0].val  # OSC address (e.g., '/angel_words')
        words = row[1].val  # OSC message content (e.g., 'word1, word2, word3')

        # Debug: Print address and words
        print(f"Address: {address}, Words: {words}")

        # Determine which category's table to update based on the address
        if address == '/angel_words':
            target_table = op('angel_table')
        elif address == '/hero_words':
            target_table = op('hero_table')
        elif address == '/feminist_words':
            target_table = op('feminist_table')
        elif address == '/rebel_words':
            target_table = op('rebel_table')
        else:
            print(f"Unrecognized OSC address: {address}")
            continue  # Ignore unrecognized addresses

        # Update the target table with the words
        words_list = words.split(', ')  # Split the words into a list
        target_table.clear()  # Clear the current contents of the table

        # Fill the table with the new words
        for word in words_list:
            target_table.appendRow([word])

    return

def onTableRowChange(dat, rows):
    return

def onTableColChange(dat, cols):
    return

def onTableCellChange(dat, cells):
    return

def onPulse(par):
    return

Setting Up TouchDesigner:

1. OSC In DAT: Add an OSC In DAT, set the network address to 127.0.0.1 and the port to 9000.
2. Table DATs: Add four Table DATs for each category and rename them to angel_table, hero_table, feminist_table, and rebel_table.
3. DAT Execute DAT: Add a DAT Execute DAT and connect it to the OSC In DAT.
   • Paste the updated script into the DAT Execute DAT script editor.
   • Enable the onTableChange function.

Debugging Tips:

• Check OSC Data: Verify that the OSC In DAT is receiving data correctly. The debug print statements should output the incoming data, addresses, and words.
• Data Format: Ensure that each OSC message has the correct format with two columns: the address and the message content.
• Table DAT Names: Ensure that the Table DAT names match exactly with those specified in the script (angel_table, hero_table, feminist_table, rebel_table).

By following these steps and using the updated script, you should be able to dynamically update the Table DATs with the matched words based on the OSC messages. The debug output should help identify any issues if they persist.

You

okay this isn’t throwing any errors but the words are not being displayed in the DAT tables

ChatGPT

Let’s ensure the script correctly identifies and processes the OSC messages, updating the corresponding Table DATs properly. We will add more detailed debugging information to understand where the script might be failing.

Here is the updated script with enhanced debugging and some additional checks:

Updated Script

def onTableChange(dat):
    # This function is called whenever the OSC In DAT is updated
    print("OSC In DAT updated. Content:")

    # Debug: Print the contents of the OSC In DAT
    for row in dat.rows():
        print([cell.val for cell in row])

    # Iterate through the rows of the OSC In DAT
    for row in dat.rows():
        # Ensure row has at least two columns to avoid index errors
        if len(row) < 2:
            print("Row does not have enough columns:", row)
            continue

        address = row[0].val  # OSC address (e.g., '/angel_words')
        words = row[1].val  # OSC message content (e.g., 'word1, word2, word3')

        # Debug: Print address and words
        print(f"Address: {address}, Words: {words}")

        # Determine which category's table to update based on the address
        if address == '/angel_words':
            target_table = op('angel_table')
        elif address == '/hero_words':
            target_table = op('hero_table')
        elif address == '/feminist_words':
            target_table = op('feminist_table')
        elif address == '/rebel_words':
            target_table = op('rebel_table')
        else:
            print(f"Unrecognized OSC address: {address}")
            continue  # Ignore unrecognized addresses

        # Debug: Print the target table name
        print(f"Target Table: {target_table.name}")

        # Update the target table with the words
        words_list = words.split(', ')  # Split the words into a list
        target_table.clear()  # Clear the current contents of the table

        # Fill the table with the new words
        for word in words_list:
            target_table.appendRow([word])

        # Debug: Print the contents of the updated table
        print(f"Updated {target_table.name} contents:")
        for row in target_table.rows():
            print([cell.val for cell in row])

    return

def onTableRowChange(dat, rows):
    return

def onTableColChange(dat, cols):
    return

def onTableCellChange(dat, cells):
    return

def onPulse(par):
    return

Setting Up TouchDesigner:

1. OSC In DAT: Add an OSC In DAT, set the network address to 127.0.0.1 and the port to 9000.
2. Table DATs: Add four Table DATs for each category and rename them to angel_table, hero_table, feminist_table, and rebel_table.
3. DAT Execute DAT: Add a DAT Execute DAT and connect it to the OSC In DAT.
   • Paste the updated script into the DAT Execute DAT script editor.
   • Enable the onTableChange function.

Debugging Tips:

• Verify OSC Data Reception: Check that the OSC In DAT is receiving data. You should see rows of data in the OSC In DAT.
• Check Console Output: Look at the text port (console) in TouchDesigner to see the debug output. The script prints the contents of the OSC In DAT, the addresses and words received, and the target table being updated.
• Table DAT Names: Ensure the Table DAT names (angel_table, hero_table, feminist_table, rebel_table) match exactly with those specified in the script.

By following these steps and reviewing the debug output in the console, you should be able to identify why the words are not being displayed in the Table DATs. The detailed print statements will help you trace the flow of data and understand where it might be getting lost or misprocessed.

You

OSC In DAT updated. Content: [‘message’] [‘/angel_words ""’] [‘/hero_words ""’] [‘/feminist_words ""’] [‘/rebel_words ""’] Row does not have enough columns: [type:Cell cell:(0, 0) owner:/project1/oscin1 value:message] Row does not have enough columns: [type:Cell cell:(1, 0) owner:/project1/oscin1 value:/angel_words ""] Row does not have enough columns: [type:Cell cell:(2, 0) owner:/project1/oscin1 value:/hero_words ""] Row does not have enough columns: [type:Cell cell:(3, 0) owner:/project1/oscin1 value:/feminist_words ""] Row does not have enough columns: [type:Cell cell:(4, 0) owner:/project1/oscin1 value:/rebel_words ""] python >>>

ChatGPT

It seems like the OSC messages are being received as single cells containing both the address and the message content as a single string. We need to split this data properly to separate the address from the message content.

Let’s update the script to handle this correctly by splitting the row content based on the space character and ensuring we properly parse the OSC message format.

Updated Script

def onTableChange(dat):
    # This function is called whenever the OSC In DAT is updated
    print("OSC In DAT updated. Content:")

    # Debug: Print the contents of the OSC In DAT
    for row in dat.rows():
        print([cell.val for cell in row])

    # Iterate through the rows of the OSC In DAT
    for row in dat.rows():
        # Ensure row has at least one column to avoid index errors
        if len(row) < 1:
            print("Row does not have enough columns:", row)
            continue

        # Split the single cell value into address and message content
        data = row[0].val.split(' ', 1)
        if len(data) < 2:
            print("Row does not contain a valid address and message:", row)
            continue

        address = data[0]  # OSC address (e.g., '/angel_words')
        words = data[1].strip('""')  # OSC message content (e.g., 'word1, word2, word3')

        # Debug: Print address and words
        print(f"Address: {address}, Words: {words}")

        # Determine which category's table to update based on the address
        if address == '/angel_words':
            target_table = op('angel_table')
        elif address == '/hero_words':
            target_table = op('hero_table')
        elif address == '/feminist_words':
            target_table = op('feminist_table')
        elif address == '/rebel_words':
            target_table = op('rebel_table')
        else:
            print(f"Unrecognized OSC address: {address}")
            continue  # Ignore unrecognized addresses

        # Debug: Print the target table name
        print(f"Target Table: {target_table.name}")

        # Update the target table with the words
        words_list = words.split(', ')  # Split the words into a list
        target_table.clear()  # Clear the current contents of the table

        # Fill the table with the new words
        for word in words_list:
            target_table.appendRow([word])

        # Debug: Print the contents of the updated table
        print(f"Updated {target_table.name} contents:")
        for table_row in target_table.rows():
            print([cell.val for cell in table_row])

    return

def onTableRowChange(dat, rows):
    return

def onTableColChange(dat, cols):
    return

def onTableCellChange(dat, cells):
    return

def onPulse(par):
    return

Setting Up TouchDesigner:

1. OSC In DAT: Add an OSC In DAT, set the network address to 127.0.0.1 and the port to 9000.
2. Table DATs: Add four Table DATs for each category and rename them to angel_table, hero_table, feminist_table, and rebel_table.
3. DAT Execute DAT: Add a DAT Execute DAT and connect it to the OSC In DAT.
   • Paste the updated script into the DAT Execute DAT script editor.
   • Enable the onTableChange function.

Debugging Tips:

• Check OSC Data Reception: Verify that the OSC In DAT is receiving data. You should see rows of data in the OSC In DAT.
• Check Console Output: Look at the text port (console) in TouchDesigner to see the debug output. The script prints the contents of the OSC In DAT, the addresses and words received, and the target table being updated.
• Table DAT Names: Ensure the Table DAT names (angel_table, hero_table, feminist_table, rebel_table) match exactly with those specified in the script.

By following these steps and reviewing the debug output in the console, you should be able to dynamically update the Table DATs with the matched words based on the OSC messages. The detailed print statements will help you trace the flow of data and understand where it might be getting lost or misprocessed.

You

perfect this works. I now need to take the words in the 4 tables and use them to create text on the top output

ChatGPT

Great to hear that the table update is working! Now, let’s create text on the top output using the words from the four tables.

To achieve this, we will:

1. Add a Text TOP for displaying the combined words.
2. Use a Python script to dynamically update the Text TOP based on the content of the four tables.

Here’s how to do it:

Steps:

1. Add a Text TOP:

   • Add a Text TOP to your project. This will display the combined words.
   • Rename the Text TOP to something meaningful, like combined_text.

2. Add a Script DAT:

   • Add a Script DAT that will contain the script to update the Text TOP.
   • Rename the Script DAT to something like update_text_script.

3. Write the Script:

   • Write a script that reads the words from the four tables and updates the Text TOP.

Here’s the script you can use in the Script DAT:

Script to Update Text TOP

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('combined_text')

    # Read words from each table and combine them into a single string
    combined_words = []

    for table in [angel_table, hero_table, feminist_table, rebel_table]:
        for row in table.rows():
            if len(row) > 0:
                combined_words.append(row[0].val)

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

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

    return

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

Automatically Update Text TOP on Table Change:

To ensure the Text TOP updates automatically whenever the table contents change, we need to call the update_text function from the DAT Execute DAT.

4. Modify the DAT Execute Script:
   • In your existing DAT Execute DAT, add a call to the update_text function at the end of the onTableChange function.

Here’s the updated script for the DAT Execute DAT:

def onTableChange(dat):
    # This function is called whenever the OSC In DAT is updated
    print("OSC In DAT updated. Content:")

    # Debug: Print the contents of the OSC In DAT
    for row in dat.rows():
        print([cell.val for cell in row])

    # Iterate through the rows of the OSC In DAT
    for row in dat.rows():
        # Ensure row has at least one column to avoid index errors
        if len(row) < 1:
            print("Row does not have enough columns:", row)
            continue

        # Split the single cell value into address and message content
        data = row[0].val.split(' ', 1)
        if len(data) < 2:
            print("Row does not contain a valid address and message:", row)
            continue

        address = data[0]  # OSC address (e.g., '/angel_words')
        words = data[1].strip('""')  # OSC message content (e.g., 'word1, word2, word3')

        # Debug: Print address and words
        print(f"Address: {address}, Words: {words}")

        # Determine which category's table to update based on the address
        if address == '/angel_words':
            target_table = op('angel_table')
        elif address == '/hero_words':
            target_table = op('hero_table')
        elif address == '/feminist_words':
            target_table = op('feminist_table')
        elif address == '/rebel_words':
            target_table = op('rebel_table')
        else:
            print(f"Unrecognized OSC address: {address}")
            continue  # Ignore unrecognized addresses

        # Debug: Print the target table name
        print(f"Target Table: {target_table.name}")

        # Update the target table with the words
        words_list = words.split(', ')  # Split the words into a list
        target_table.clear()  # Clear the current contents of the table

        # Fill the table with the new words
        for word in words_list:
            target_table.appendRow([word])

        # Debug: Print the contents of the updated table
        print(f"Updated {target_table.name} contents:")
        for table_row in target_table.rows():
            print([cell.val for cell in table_row])

    # Call the update_text function to update the Text TOP
    op('update_text_script').run()

    return

def onTableRowChange(dat, rows):
    return

def onTableColChange(dat, cols):
    return

def onTableCellChange(dat, cells):
    return

def onPulse(par):
    return

Summary:

1. Text TOP: Add a Text TOP named combined_text.
2. Script DAT: Add a Script DAT named update_text_script with the provided script to update the Text TOP.
3. DAT Execute DAT: Modify the existing DAT Execute DAT script to call update_text_script to update the Text TOP whenever the tables change.

This setup will ensure that the words in the four tables are combined and displayed in the Text TOP, updating dynamically as the table contents change.

You

OSC In DAT updated. Content: [‘message’] [‘/angel_words ""’] [‘/hero_words ""’] [‘/feminist_words ""’] [‘/rebel_words ""’] Row does not contain a valid address and message: [type:Cell cell:(0, 0) owner:/project1/oscin1 value:message] Address: /angel_words, Words: Target Table: angel_table Updated angel_table contents: [”] Address: /hero_words, Words: Target Table: hero_table Updated hero_table contents: [”] Address: /feminist_words, Words: Target Table: feminist_table Updated feminist_table contents: [”] Address: /rebel_words, Words: Target Table: rebel_table Updated rebel_table contents: [”] python >>>

ChatGPT

It looks like the OSC messages are coming in with empty strings for the words. This may be due to how the messages are being sent from the Python script. We should ensure that the script sends the correct message format.

In the current setup, it seems the messages are formatted incorrectly. Let’s adjust the message sending part of the Python script to ensure it’s sending valid OSC messages.

Here’s the updated Python script to send proper OSC messages:

Sending Proper OSC Messages

# 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

Updating TouchDesigner Script

Now, let’s make sure the TouchDesigner script handles the empty strings correctly and updates the Text TOP.

Script to Update Text TOP in TouchDesigner

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('combined_text')

    # Read words from each table and combine them into a single string
    combined_words = []

    for table in [angel_table, hero_table, feminist_table, rebel_table]:
        for row in table.rows():
            if len(row) > 0 and row[0].val.strip():  # Ensure no empty strings
                combined_words.append(row[0].val)

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

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

    return

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

Modify the DAT Execute Script

Update the DAT Execute DAT script to handle empty messages correctly:

def onTableChange(dat):
    # This function is called whenever the OSC In DAT is updated
    print("OSC In DAT updated. Content:")

    # Debug: Print the contents of the OSC In DAT
    for row in dat.rows():
        print([cell.val for cell in row])

    # Iterate through the rows of the OSC In DAT
    for row in dat.rows():
        # Ensure row has at least one column to avoid index errors
        if len(row) < 1:
            print("Row does not have enough columns:", row)
            continue

        # Split the single cell value into address and message content
        data = row[0].val.split(' ', 1)
        if len(data) < 2:
            print("Row does not contain a valid address and message:", row)
            continue

        address = data[0]  # OSC address (e.g., '/angel_words')
        words = data[1].strip('""')  # OSC message content (e.g., 'word1, word2, word3')

        # Debug: Print address and words
        print(f"Address: {address}, Words: {words}")

        # Determine which category's table to update based on the address
        if address == '/angel_words':
            target_table = op('angel_table')
        elif address == '/hero_words':
            target_table = op('hero_table')
        elif address == '/feminist_words':
            target_table = op('feminist_table')
        elif address == '/rebel_words':
            target_table = op('rebel_table')
        else:
            print(f"Unrecognized OSC address: {address}")
            continue  # Ignore unrecognized addresses

        # Debug: Print the target table name
        print(f"Target Table: {target_table.name}")

        # Update the target table with the words
        words_list = words.split(', ') if words.strip() else []  # Split the words into a list
        target_table.clear()  # Clear the current contents of the table

        # Fill the table with the new words
        for word in words_list:
            target_table.appendRow([word])

        # Debug: Print the contents of the updated table
        print(f"Updated {target_table.name} contents:")
        for table_row in target_table.rows():
            print([cell.val for cell in table_row])

    # Call the update_text function to update the Text TOP
    op('update_text_script').run()

    return

def onTableRowChange(dat, rows):
    return

def onTableColChange(dat, cols):
    return

def onTableCellChange(dat, cells):
    return

def onPulse(par):
    return

Summary:

1. Send Proper OSC Messages: Update the Python script to send valid OSC messages, even when there are no matched words.
2. Text TOP: Ensure the Text TOP is updated correctly with the combined words from the tables.
3. Handle Empty Strings: Ensure the TouchDesigner script handles empty strings correctly and only updates with valid words.

By following these steps, the words from the tables should be correctly combined and displayed in the Text TOP.

You

In this script currently the matched words are displayed in a bit of a mess above the column, could they be ordered vertically with some spacing between them

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)  # 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 = ', '.join(matched_words[category])
    plt.text(i, values[i] + 2, words, fontsize=8, color='black', ha='center', wrap=True)

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

ChatGPT

To display the matched words vertically above each column with some spacing between them, you can modify the plot_emotion_distribution function. Instead of joining the words with commas, we will use newline characters and adjust the vertical position of each word to create the desired spacing.

Here’s the updated plot_emotion_distribution function:

Updated plot_emotion_distribution Function

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)  # 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 * 1.2, word, fontsize=8, color='black', ha='center')

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

Explanation

1. Clear the Previous Plot: The plot is cleared using plt.clf() to ensure it starts fresh each time the function is called.
2. Create the Bar Chart: A bar chart is created using the plt.bar() function, with the bars colored according to the predefined color_mapping.
3. Adjust Plot Labels and Limits: The x-axis label, y-axis label, and plot title are set. The y-axis limit is adjusted to provide extra vertical space above the bars.
4. Handle No Matches Annotation: If there are no matches, an annotation is added to the plot indicating that a random distribution has been generated.
5. Add Matched Words Vertically:
   • For each category, the matched words are iterated through.
   • Each word is positioned above the corresponding bar, with an increasing vertical offset (2 + j * 1.2), where j is the index of the word. This ensures the words are displayed vertically with some spacing between them.

Complete Script with Updated Function

Here’s the complete script with the updated plot_emotion_distribution function:

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)  # 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 * 1.2, word, fontsize=8, color='black', ha='center')

    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

This script will display the matched words vertically above each column with a bit of spacing between them, making it more readable.

You

need to increase the spacing more

ChatGPT

Sure, we can increase the spacing between the words above each column. Let’s adjust the vertical offset to provide more space between the words.

Here’s the updated plot_emotion_distribution function with increased spacing:

Updated plot_emotion_distribution Function

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

Explanation

1. Vertical Offset Increase: The vertical offset for each word is increased by multiplying the index j by 2 instead of 1.2, which provides more spacing between the words (values[i] + 2 + j * 2).

2. Extra Vertical Space Above Bars: The y-axis limit is further adjusted to provide extra vertical space above the bars. This is done by adding 2*max(len(words) for words in matched_words.values()) to the maximum y-value, which ensures enough space for the additional lines.

Complete Script with Updated Function

Here’s the complete script with the updated plot_emotion_distribution function:

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

This script increases the vertical spacing between the words above each column, making it more readable.