Randomize Audio Spectrum Samples

2024-09-20 10:07 UTC gpt-4o Open in ChatGPT ↗

You

in touchdesigner I’ve got an audio spectrum chop which I want to reorder the samples randomly so that it’s all jumbled up. Can I use a reorder node for this?

ChatGPT

Yes, you can use the Reorder CHOP in TouchDesigner to shuffle the samples from your audio spectrum CHOP. However, the Reorder CHOP is typically used for rearranging channels and does not provide a direct way to randomly reorder the individual samples within each channel.

To achieve the random shuffling of the samples from the audio spectrum CHOP, you will need a different approach. Here’s a step-by-step method to achieve this using a combination of CHOPs:

1. Convert CHOP to DAT: Use the CHOP to DAT node to convert your audio spectrum CHOP into a DAT table. This will make each sample a separate row in a DAT, allowing for easy manipulation.

2. Shuffle DAT: Use a Shuffle DAT node to randomize the order of rows (samples). Set the shuffle method to Random to scramble the order of the samples.

3. Convert DAT back to CHOP: Once you’ve randomized the sample order in the DAT, convert the shuffled table back into a CHOP using the DAT to CHOP node.

4. Resample (optional): If you need to adjust the number of samples or re-quantize the output, you can use a Resample CHOP after converting back to CHOP.

Alternative Using Python Script

If you prefer not to use the DAT method, you could also write a small Python script in a Script CHOP to directly shuffle the samples within the CHOP itself. Here’s a rough idea of the script:

import random

def onCook(scriptOp):
    samples = [scriptOp.inputs[0][i] for i in range(scriptOp.inputs[0].numSamples)]
    random.shuffle(samples)
    for i, sample in enumerate(samples):
        scriptOp.channels[0][i] = sample
    return

This would take the input samples, shuffle them using Python’s random.shuffle(), and assign them back to the Script CHOP’s output.

By following either of these approaches, you can easily jumble up the samples from your audio spectrum CHOP.

You

Traceback (most recent call last): File “/project1/script1_callbacks”, line 7, in onCook td.tdAttributeError: ‘td.scriptCHOP’ object has no attribute ‘channels’ Context:/project1/script1 python >>>

ChatGPT

It looks like the issue is due to an incorrect attempt to access the channels attribute of the scriptOp object. In a Script CHOP, you should use scriptOp.appendChan() to create new channels, and then assign the samples to those channels properly.

Here’s the corrected Python script for shuffling samples in the Script CHOP:

import random

def onCook(scriptOp):
    # Get input CHOP samples
    inputCHOP = scriptOp.inputs[0]

    # Create an output channel in scriptOp
    for chan in inputCHOP.chans():
        scriptOp.appendChan(chan.name)

    # Iterate over each channel
    for chanIndex in range(inputCHOP.numChans):
        # Get all samples for the current channel
        samples = [inputCHOP[chanIndex][i] for i in range(inputCHOP.numSamples)]

        # Shuffle the samples
        random.shuffle(samples)

        # Assign the shuffled samples back to the output channel
        for i, sample in enumerate(samples):
            scriptOp[chanIndex][i] = sample

    return

Explanation:

1. scriptOp.inputs[0]: This gets the input CHOP.
2. scriptOp.appendChan(chan.name): This appends an empty channel to the scriptOp that corresponds to the input channel.
3. random.shuffle(samples): This shuffles the samples.
4. scriptOp[chanIndex][i] = sample: This assigns the shuffled samples back to the Script CHOP output.

This should resolve the error you’re encountering. Let me know if it works as expected!

You

I only need to run it on a channel called “ty” I’m ending up with lots of other channels. I can select this channel but currently the framerate has dropped as a result of this script. Can we optimise it or run it on just the channel “ty” please?

ChatGPT

To address the issues you’re facing, we can optimize the script to only work on the "ty" channel and improve performance.

Here’s an optimized version of the script:

1. Restrict to the "ty" channel: We’ll check if the current channel is "ty", and only shuffle that one.
2. Avoid unnecessary channel creation: We only need to append the "ty" channel to the output, which will prevent the creation of extra channels.
3. Minimize operations: We can optimize the loop and operations to reduce computational cost.

Here’s the optimized code:

import random

def onCook(scriptOp):
    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Look for the "ty" channel
    ty_channel = inputCHOP['ty'] if 'ty' in inputCHOP.channels() else None

    if ty_channel is not None:
        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Get all samples for the "ty" channel
        samples = [ty_channel[i] for i in range(inputCHOP.numSamples)]

        # Shuffle the samples
        random.shuffle(samples)

        # Assign the shuffled samples back to the output
        for i, sample in enumerate(samples):
            scriptOp['ty'][i] = sample

    return

Key Changes:

1. Check for the "ty" channel: The script checks for the "ty" channel before proceeding.
2. Only process the "ty" channel: No other channels are appended or processed.
3. Simplified output generation: We directly work with the “ty” channel’s data.

This script should reduce the framerate drop as it only processes the necessary channel instead of handling all channels. Let me know how this works for you!

You

Traceback (most recent call last): File “/project1/script1_callbacks”, line 8, in onCook td.tdAttributeError: ‘td.selectCHOP’ object has no attribute ‘channels’ Context:/project1/select6 python >>>

ChatGPT

The error you’re seeing indicates that td.selectCHOP does not have a channels() method, which is true because we should be using the chans() method or directly accessing the channels using indexing.

Here’s the fixed and optimized code:

import random

def onCook(scriptOp):
    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Check if the "ty" channel exists in the input CHOP
    if 'ty' in inputCHOP.chanNames:
        # Get the "ty" channel
        ty_channel = inputCHOP['ty']

        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Get all samples for the "ty" channel
        samples = [ty_channel[i] for i in range(inputCHOP.numSamples)]

        # Shuffle the samples
        random.shuffle(samples)

        # Assign the shuffled samples back to the output
        for i, sample in enumerate(samples):
            scriptOp['ty'][i] = sample

    return

Key Fixes:

1. Correct Channel Access: The inputCHOP['ty'] syntax is used to directly access the ty channel, and inputCHOP.chanNames is used to check if the channel exists.
2. Simplified Access: We directly index into the input CHOP to avoid unnecessary method calls that might not exist for the object.

This should now properly run and only affect the "ty" channel without causing errors. Let me know if it works smoothly!

You

Traceback (most recent call last): File “/project1/script1_callbacks”, line 8, in onCook td.tdAttributeError: ‘td.selectCHOP’ object has no attribute ‘chanNames’ Context:/project1/select6 python >>>

ChatGPT

The error you encountered happens because td.selectCHOP objects don’t have the chanNames attribute. To fix this, we can directly access the list of channels using the chans() method, which returns a list of channel objects, and we’ll check if the “ty” channel exists in that list.

Here’s the corrected script:

import random

def onCook(scriptOp):
    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Look for the "ty" channel in the input CHOP
    ty_channel = inputCHOP['ty'] if 'ty' in [chan.name for chan in inputCHOP.chans()] else None

    if ty_channel is not None:
        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Get all samples for the "ty" channel
        samples = [ty_channel[i] for i in range(inputCHOP.numSamples)]

        # Shuffle the samples
        random.shuffle(samples)

        # Assign the shuffled samples back to the output
        for i, sample in enumerate(samples):
            scriptOp['ty'][i] = sample

    return

Key Adjustments:

1. Using chans(): We use inputCHOP.chans() to get all the channels, then check if “ty” is one of the channel names.
2. Accessing Channel Data: The script checks for the "ty" channel and processes it only if it’s available.

This should resolve the error and work correctly by targeting only the “ty” channel. Let me know if this version works smoothly without any errors!

You

Still gettinbg lots of unecessary channels as outputs and a slow framerate

ChatGPT

Thank you for the update. The issue seems to be that the unnecessary channels are still being appended to the scriptOp output. To ensure that only the “ty” channel is processed and output, we need to explicitly clear out any existing or extra channels and only append the necessary “ty” channel.

Here’s an optimized version of the script:

1. Clear unnecessary channels: We will explicitly clear the channels in scriptOp before appending just the “ty” channel.
2. Optimize the operation: This version will focus solely on processing the “ty” channel without appending extra channels.

Here is the updated script:

import random

def onCook(scriptOp):
    # Clear any existing channels in scriptOp
    scriptOp.clear()

    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Check if the "ty" channel exists in the input CHOP
    if 'ty' in [chan.name for chan in inputCHOP.chans()]:
        # Get the "ty" channel
        ty_channel = inputCHOP['ty']

        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Get all samples for the "ty" channel
        samples = [ty_channel[i] for i in range(inputCHOP.numSamples)]

        # Shuffle the samples
        random.shuffle(samples)

        # Assign the shuffled samples back to the output
        for i, sample in enumerate(samples):
            scriptOp['ty'][i] = sample

    return

Key Updates:

• scriptOp.clear(): This clears any previous or extra channels that might be lingering from the input or output process. It ensures that only the “ty” channel is appended.
• Optimized processing: We now focus entirely on the “ty” channel, preventing the addition of extra unnecessary channels.

This should reduce the number of channels significantly and improve the frame rate. Let me know how this works for your setup!

You

Okay this works great. Can we further optimise it because we’re losing alot of framerate

ChatGPT

Great to hear that the script works now! To further optimize performance and minimize the impact on frame rate, we can explore several strategies:

Key Optimization Ideas:

1. Minimize Operations per Frame: Only shuffle the “ty” channel when necessary.
2. Use NumPy for Faster Array Operations: Python’s random.shuffle() is not optimized for large arrays, but we can leverage NumPy for faster shuffling.
3. Conditional Execution: You can add a frame skip mechanism to only process the script at intervals, reducing the load per frame.

Optimized Version Using NumPy:

This version uses NumPy, which is much more efficient for large arrays. Make sure NumPy is installed and available in your TouchDesigner environment.

import numpy as np
import random

def onCook(scriptOp):
    # Clear any existing channels in scriptOp
    scriptOp.clear()

    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Check if the "ty" channel exists in the input CHOP
    if 'ty' in [chan.name for chan in inputCHOP.chans()]:
        # Get the "ty" channel
        ty_channel = inputCHOP['ty']

        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Convert the "ty" channel samples to a NumPy array for faster shuffling
        samples = np.array([ty_channel[i] for i in range(inputCHOP.numSamples)])

        # Shuffle the samples using NumPy's shuffle (faster than Python's random.shuffle)
        np.random.shuffle(samples)

        # Assign the shuffled samples back to the output
        for i in range(inputCHOP.numSamples):
            scriptOp['ty'][i] = samples[i]

    return

Further Optimizations:

1. Frame Skip (Running at Intervals): Instead of running the code on every frame, you can run it every few frames. You can add a frame counter to reduce how often the script runs:

   import numpy as np
   import random
   
   frameCount = 0
   
   def onCook(scriptOp):
       global frameCount
       frameCount += 1
   
       # Only run the script every 5 frames (change the number to adjust frequency)
       if frameCount % 5 != 0:
           return
   
       # Clear any existing channels in scriptOp
       scriptOp.clear()
   
       # Get input CHOP
       inputCHOP = scriptOp.inputs[0]
   
       # Check if the "ty" channel exists in the input CHOP
       if 'ty' in [chan.name for chan in inputCHOP.chans()]:
           # Get the "ty" channel
           ty_channel = inputCHOP['ty']
   
           # Append the "ty" channel to the output
           scriptOp.appendChan('ty')
   
           # Convert the "ty" channel samples to a NumPy array for faster shuffling
           samples = np.array([ty_channel[i] for i in range(inputCHOP.numSamples)])
   
           # Shuffle the samples using NumPy's shuffle (faster than Python's random.shuffle)
           np.random.shuffle(samples)
   
           # Assign the shuffled samples back to the output
           for i in range(inputCHOP.numSamples):
               scriptOp['ty'][i] = samples[i]
   
       return

   By skipping frames, you reduce the workload per frame but still keep a smooth animation depending on how frequently the shuffle is applied.

2. Profiling for Bottlenecks: If performance is still an issue, you might want to profile where the bottleneck is—whether it’s the shuffling, channel appending, or somewhere else. This can help target specific areas for more optimizations.

3. Reducing Sample Size (Optional): If the number of samples in the ty channel is very large, you might want to reduce the sample size before processing by using a Resample CHOP before the Script CHOP.

These optimizations should significantly improve performance while maintaining the effect you’re aiming for. Let me know if you see improvements!

You

Are there other methods of optimisation that don’t involve skipping frames? Maybe not enumerating through individually but batch processing all the samples every frame?

ChatGPT

Yes, there are more optimization techniques we can explore that don’t involve frame skipping and focus on processing the samples in bulk. The key idea is to avoid looping through individual samples and instead handle the entire array of samples at once, leveraging vectorized operations with NumPy, which can dramatically speed up performance.

Batch Processing with NumPy

Instead of iterating through each sample one by one, we can directly assign the shuffled samples back to the output in a more efficient way. Here’s an improved approach that avoids for loops for sample assignment:

Optimized Script with Bulk Sample Processing

import numpy as np

def onCook(scriptOp):
    # Clear any existing channels in scriptOp
    scriptOp.clear()

    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Check if the "ty" channel exists in the input CHOP
    if 'ty' in [chan.name for chan in inputCHOP.chans()]:
        # Get the "ty" channel
        ty_channel = inputCHOP['ty']

        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Convert the "ty" channel samples to a NumPy array for faster processing
        samples = np.array(ty_channel.vals)  # Access all samples at once

        # Shuffle the samples in bulk
        np.random.shuffle(samples)

        # Assign the shuffled array back in one step (batch processing)
        scriptOp['ty'].vals = samples

    return

Key Optimizations:

1. Bulk Accessing and Assigning Samples:

   • Instead of iterating over the samples, we’re now accessing all of the samples at once using ty_channel.vals, which returns an array of all values in the channel.
   • After shuffling the samples in bulk with np.random.shuffle(), we assign the entire shuffled array back to the output in one operation: scriptOp['ty'].vals = samples. This removes the overhead of looping and significantly speeds up the processing by treating the samples as a bulk array.

2. Avoid Python for Loops:

   • Python loops can be slow when handling large arrays of data. By using NumPy, we eliminate the need for Python loops and rely on NumPy’s highly optimized internal loops.

3. Efficient Memory Access:

   • By accessing all samples at once (vals), we’re minimizing the interaction with TouchDesigner’s API on a per-sample basis, reducing the number of function calls and improving performance.

Other Optimizations Without Skipping Frames:

1. Reduce Sample Size:

   • You can use the Resample CHOP to downsample the signal before feeding it into the Script CHOP. This way, you’ll be dealing with fewer samples and reducing computational load without affecting frame updates. For example, if you have 10,000 samples, reducing them to 5,000 will halve the load.

2. Lower Precision If Applicable:

   • If your application doesn’t require high precision, consider reducing the data precision (e.g., using fewer decimal places for the sample values) to lower the amount of data that needs to be processed and shuffled.

3. Reordering the Samples Using Math CHOP:

   • Instead of using a Python script, you might be able to achieve the reordering in TouchDesigner using Math CHOP or Noise CHOP to modify the index of samples in a more efficient way. For example, using a random index generated by Noise CHOP to reorder the samples.

Profiling for Bottlenecks:

If you’re still experiencing frame rate drops, it might be a good idea to profile your network further to check for other potential bottlenecks. TouchDesigner has a Performance Monitor that can help identify whether it’s the Script CHOP or other parts of the network causing the frame drops.

Conclusion:

This method of handling all samples as a batch through NumPy should significantly reduce the overhead caused by looping through samples and improve performance. If you still encounter performance issues, we can continue optimizing by profiling specific parts of the process or the broader network. Let me know how this works!

You

perfect that works great. Can we now play with different ways of sorting. Currently we’re sorting them randomly. Could we instead sort them using a sine pattern or some other effect?

ChatGPT

Awesome! Now that we have an optimized solution for shuffling the samples, we can certainly explore different sorting patterns like sine waves or other mathematical functions. Below, I’ll outline how to implement a few interesting sorting methods using sine wave patterns, linear patterns, and even custom noise patterns.

1. Sine Wave Sorting

We can sort the values of the “ty” channel based on their corresponding sine values. This will create a smooth sine wave-like pattern in the samples.

import numpy as np

def onCook(scriptOp):
    # Clear any existing channels in scriptOp
    scriptOp.clear()

    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Check if the "ty" channel exists in the input CHOP
    if 'ty' in [chan.name for chan in inputCHOP.chans()]:
        # Get the "ty" channel
        ty_channel = inputCHOP['ty']

        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Convert the "ty" channel samples to a NumPy array for faster processing
        samples = np.array(ty_channel.vals)  # Get the samples as an array

        # Generate a sine wave based on the number of samples
        num_samples = inputCHOP.numSamples
        sine_wave = np.sin(np.linspace(0, 2 * np.pi, num_samples))

        # Sort the samples based on the sine wave values
        sorted_indices = np.argsort(sine_wave)
        sorted_samples = samples[sorted_indices]

        # Assign the sorted samples back in one step (bulk processing)
        scriptOp['ty'].vals = sorted_samples

    return

How It Works:

• np.sin(np.linspace(0, 2 * np.pi, num_samples)): This generates a smooth sine wave pattern.
• np.argsort(sine_wave): This gets the indices that would sort the sine wave. We apply this ordering to the original sample data, creating a sine-like variation in the values.

2. Linear Sorting (Ascending or Descending)

If you want to simply sort the values in ascending or descending order, you can do this easily using np.sort() or reverse sorting.

import numpy as np

def onCook(scriptOp):
    # Clear any existing channels in scriptOp
    scriptOp.clear()

    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Check if the "ty" channel exists in the input CHOP
    if 'ty' in [chan.name for chan in inputCHOP.chans()]:
        # Get the "ty" channel
        ty_channel = inputCHOP['ty']

        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Convert the "ty" channel samples to a NumPy array for faster processing
        samples = np.array(ty_channel.vals)

        # Sort the samples in ascending order
        sorted_samples = np.sort(samples)

        # Alternatively, for descending order: sorted_samples = np.sort(samples)[::-1]

        # Assign the sorted samples back in one step
        scriptOp['ty'].vals = sorted_samples

    return

How It Works:

• np.sort(samples): Sorts the sample values in ascending order.
• [::-1]: This reverses the sorted array, making it descending if needed.

3. Custom Noise Pattern Sorting

We can use a noise pattern to sort the samples, which could give a more chaotic but structured result. Here, we use Perlin noise or any custom noise to generate the sorting order.

import numpy as np

def onCook(scriptOp):
    # Clear any existing channels in scriptOp
    scriptOp.clear()

    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Check if the "ty" channel exists in the input CHOP
    if 'ty' in [chan.name for chan in inputCHOP.chans()]:
        # Get the "ty" channel
        ty_channel = inputCHOP['ty']

        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Convert the "ty" channel samples to a NumPy array for faster processing
        samples = np.array(ty_channel.vals)

        # Generate a random noise pattern based on the number of samples
        noise = np.random.rand(inputCHOP.numSamples)  # You can replace with any other noise algorithm

        # Sort the samples based on the noise values
        sorted_indices = np.argsort(noise)
        sorted_samples = samples[sorted_indices]

        # Assign the sorted samples back in one step
        scriptOp['ty'].vals = sorted_samples

    return

How It Works:

• np.random.rand(inputCHOP.numSamples): Generates random noise values, which we use to sort the samples.
• This can be replaced with more sophisticated noise generation algorithms like Perlin noise for a more organic pattern.

4. Exponential Sorting

We can also sort the samples based on an exponential function, which will create a fast-growing curve in the data. This could be useful for effects where the data needs to grow or decay in intensity.

import numpy as np

def onCook(scriptOp):
    # Clear any existing channels in scriptOp
    scriptOp.clear()

    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Check if the "ty" channel exists in the input CHOP
    if 'ty' in [chan.name for chan in inputCHOP.chans()]:
        # Get the "ty" channel
        ty_channel = inputCHOP['ty']

        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Convert the "ty" channel samples to a NumPy array for faster processing
        samples = np.array(ty_channel.vals)

        # Generate an exponential curve for sorting
        exp_curve = np.exp(np.linspace(0, 5, inputCHOP.numSamples))  # Exponential growth

        # Sort the samples based on the exponential values
        sorted_indices = np.argsort(exp_curve)
        sorted_samples = samples[sorted_indices]

        # Assign the sorted samples back in one step
        scriptOp['ty'].vals = sorted_samples

    return

How It Works:

• np.exp(np.linspace(0, 5, inputCHOP.numSamples)): Generates an exponentially growing curve to sort the data. The range of np.linspace() can be adjusted to control the steepness of the curve.

---

Summary:

• Sine Sorting: Creates a smooth, wave-like variation in the data.
• Linear Sorting: Simple ascending or descending sorting.
• Noise-Based Sorting: Introduces chaos but with a structured randomness.
• Exponential Sorting: Creates a fast-growing or decaying effect in the data.

You can experiment with these methods to create different effects in your project. Let me know which ones you find most interesting or if you want to explore more complex patterns!

You

The sine wave sorting great as it’s creating nice peaks in the resulting line that I’m distorting, can we sort it with a bit of sine-n ess and a bit of randomness?

ChatGPT

To create a mix of sine wave sorting with a touch of randomness, we can combine both effects by blending the sine wave pattern with some random noise. This will give you the nice structured peaks of the sine wave but with a bit of chaotic variation to make it feel more organic.

Here’s how we can implement it:

1. Generate the sine wave pattern.
2. Generate a random noise pattern.
3. Blend the two patterns by adding a weighted amount of noise to the sine wave.
4. Sort the samples based on this blended pattern.

Code Example for Sine + Random Blended Sorting:

import numpy as np

def onCook(scriptOp):
    # Clear any existing channels in scriptOp
    scriptOp.clear()

    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Check if the "ty" channel exists in the input CHOP
    if 'ty' in [chan.name for chan in inputCHOP.chans()]:
        # Get the "ty" channel
        ty_channel = inputCHOP['ty']

        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Convert the "ty" channel samples to a NumPy array for faster processing
        samples = np.array(ty_channel.vals)

        # Generate a sine wave pattern
        num_samples = inputCHOP.numSamples
        sine_wave = np.sin(np.linspace(0, 2 * np.pi, num_samples))

        # Generate a random noise pattern
        noise = np.random.rand(num_samples) * 0.5  # You can control the noise intensity (e.g., 0.5)

        # Blend the sine wave and random noise
        blend_factor = 0.8  # Controls the amount of sine wave vs randomness (1 = pure sine, 0 = pure random)
        blended_pattern = sine_wave * blend_factor + noise * (1 - blend_factor)

        # Sort the samples based on the blended pattern
        sorted_indices = np.argsort(blended_pattern)
        sorted_samples = samples[sorted_indices]

        # Assign the sorted samples back in one step
        scriptOp['ty'].vals = sorted_samples

    return

Explanation:

1. Sine Wave Generation: sine_wave = np.sin(np.linspace(0, 2 * np.pi, num_samples)) generates a sine wave pattern.

2. Random Noise Generation: noise = np.random.rand(num_samples) * 0.5 creates random noise, and multiplying by 0.5 controls the noise intensity (you can adjust this value as needed).

3. Blending the Two Patterns:

   • blend_factor = 0.8: This controls how much of the sine wave is retained versus how much randomness is introduced.
     • 1.0 means it’s pure sine wave.
     • 0.0 means it’s pure randomness.
     • Values like 0.8 (80% sine, 20% noise) allow for a balance of structured and chaotic behavior.
   • The final blended pattern is computed as blended_pattern = sine_wave * blend_factor + noise * (1 - blend_factor).

4. Sorting Based on the Blended Pattern:

   • We sort the samples using the blended sine-random pattern: sorted_indices = np.argsort(blended_pattern), which mixes sine structure with randomness.

5. Assigning Sorted Samples: Finally, we assign the sorted samples in bulk back to the output using scriptOp['ty'].vals = sorted_samples.

Customizing the Blend:

• Adjusting Noise Intensity:
  • Change noise = np.random.rand(num_samples) * 0.5 to a different factor (like 0.2 for less randomness or 0.8 for more randomness).
• Adjusting Blend Factor:
  • Modify blend_factor = 0.8 to different values depending on how dominant you want the sine wave to be versus the randomness.
  • Lower blend factors (e.g., 0.5) will introduce more randomness into the peaks and troughs of the sine wave.

Visual Effect:

• You’ll get nice, smooth sine-like peaks with some randomness added to create a more organic and less predictable distortion, ideal for dynamic visual effects that are both structured and chaotic.

Let me know how this works for you or if you’d like to explore further refinements!

You

I’m using this sorting to reorder the points of an auido spectrum which create this line. At the moment the peaks are spread too predicatbly (right is bass, left are highs) what I want is that the frequencies are more randmly placed along the line or ideally they could move with a phase?

ChatGPT

To make the frequency peaks appear less predictable and introduce some movement, you can apply a phase shift to the sine wave and randomize the frequency placement. This will allow you to create a more organic motion over time and scatter the frequencies more randomly along the line.

Here’s the plan:

1. Random Frequency Placement: You can randomly shuffle the positions of the frequencies themselves.
2. Sine Wave with Phase: Add a phase shift to the sine wave to introduce movement over time.
3. Dynamic Blend of Phase and Randomization: Combine both the sine wave phase and randomness so that the frequencies appear to oscillate, but still follow an unpredictable pattern.

Updated Code with Phase Shifting and Random Frequency Placement

import numpy as np

def onCook(scriptOp):
    # Clear any existing channels in scriptOp
    scriptOp.clear()

    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Check if the "ty" channel exists in the input CHOP
    if 'ty' in [chan.name for chan in inputCHOP.chans()]:
        # Get the "ty" channel
        ty_channel = inputCHOP['ty']

        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Convert the "ty" channel samples to a NumPy array for faster processing
        samples = np.array(ty_channel.vals)

        # Generate a sine wave with a phase that moves over time
        num_samples = inputCHOP.numSamples
        time = abs(scriptOp.frame)  # Use the current frame as time reference
        phase_shift = (2 * np.pi) * (time * 0.01)  # Adjust 0.01 for speed of movement

        sine_wave = np.sin(np.linspace(0, 2 * np.pi, num_samples) + phase_shift)

        # Randomize the frequency placement to reduce predictability
        random_indices = np.random.permutation(num_samples)  # Randomly shuffle indices
        randomized_frequencies = sine_wave[random_indices]  # Apply shuffle to sine wave

        # Blend random frequencies and sine pattern
        blend_factor = 0.6  # Adjust blend factor to control how much randomization vs sine
        blended_pattern = sine_wave * blend_factor + randomized_frequencies * (1 - blend_factor)

        # Sort the samples based on the blended pattern
        sorted_indices = np.argsort(blended_pattern)
        sorted_samples = samples[sorted_indices]

        # Assign the sorted samples back in one step
        scriptOp['ty'].vals = sorted_samples

    return

Key Elements of the Code:

1. Phase Shift in Sine Wave:

   • phase_shift = (2 * np.pi) * (time * 0.01): The phase shift changes over time, creating movement in the sine wave.
   • You can adjust the 0.01 value to control how fast the phase shifts and how quickly the peaks move across the line.

2. Random Frequency Placement:

   • random_indices = np.random.permutation(num_samples): This randomizes the indices, making the frequency distribution less predictable.
   • By shuffling the sine wave with these random indices, the positions of high and low frequencies become more random.

3. Blending Random and Sine Patterns:

   • blended_pattern = sine_wave * blend_factor + randomized_frequencies * (1 - blend_factor): This blends the sine wave pattern with the randomized positions. The blend_factor controls how much of each pattern you use.
     • Higher blend factors (e.g., 0.8) will favor the sine wave structure, while lower blend factors (e.g., 0.4) will create more randomness.

4. Dynamic Motion Over Time:

   • The time variable (abs(scriptOp.frame)) is used to make the phase shift dynamic. This means the sine wave will move smoothly over time, causing the peaks to appear to shift along the line.

Customization:

• Speed of Movement: Adjust the phase_shift equation by changing the multiplier 0.01 to speed up or slow down the phase motion.
• Randomization Intensity: You can fine-tune the blend_factor to control how random or sine-like the pattern looks.
• Motion Pattern: If you want to introduce more complex motion, you can replace the sine wave with a combination of waveforms (like a triangle wave, square wave, or any other mathematical function).

This approach will allow the peaks to move and frequencies to be placed randomly, with a smooth shifting effect over time. The combination of randomness and phase shift should give you more dynamic and less predictable behavior, while still keeping an underlying sine structure.

Let me know how this looks in your project!

You

Traceback (most recent call last): File “/project1/script1_callbacks”, line 23, in onCook td.tdAttributeError: ‘td.scriptCHOP’ object has no attribute ‘frame’ Context:/project1/script1 python >>>

ChatGPT

The error occurs because the td.scriptCHOP object does not have a frame attribute. Instead, we need to use the absTime.frame from the global op context in TouchDesigner, which gives the current frame number.

Here’s the corrected version of the script that uses op.time.frame for the current frame:

import numpy as np

def onCook(scriptOp):
    # Clear any existing channels in scriptOp
    scriptOp.clear()

    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Check if the "ty" channel exists in the input CHOP
    if 'ty' in [chan.name for chan in inputCHOP.chans()]:
        # Get the "ty" channel
        ty_channel = inputCHOP['ty']

        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Convert the "ty" channel samples to a NumPy array for faster processing
        samples = np.array(ty_channel.vals)

        # Use the global TouchDesigner frame time for dynamic phase shifting
        time = op.time.frame  # Get the current frame number

        # Adjust the phase shift based on time
        phase_shift = (2 * np.pi) * (time * 0.01)  # Adjust 0.01 for speed of movement

        # Generate a sine wave with the phase shift
        num_samples = inputCHOP.numSamples
        sine_wave = np.sin(np.linspace(0, 2 * np.pi, num_samples) + phase_shift)

        # Randomize the frequency placement to reduce predictability
        random_indices = np.random.permutation(num_samples)  # Randomly shuffle indices
        randomized_frequencies = sine_wave[random_indices]  # Apply shuffle to sine wave

        # Blend random frequencies and sine pattern
        blend_factor = 0.6  # Adjust blend factor to control how much randomization vs sine
        blended_pattern = sine_wave * blend_factor + randomized_frequencies * (1 - blend_factor)

        # Sort the samples based on the blended pattern
        sorted_indices = np.argsort(blended_pattern)
        sorted_samples = samples[sorted_indices]

        # Assign the sorted samples back in one step
        scriptOp['ty'].vals = sorted_samples

    return

Changes:

• op.time.frame: This gets the current frame from TouchDesigner’s global time. The op.time.frame will give you the correct frame number to use for the phase shifting.

Other Customizations:

• You can adjust the phase_shift multiplier (e.g., 0.01) to control how fast the sine wave moves over time, and the blend_factor can be used to tweak the randomness vs sine structure.

This should resolve the tdAttributeError and provide the desired dynamic behavior over time. Let me know how it works for you!

You

Traceback (most recent call last): File “/project1/script1_callbacks”, line 22, in onCook td.tdAttributeError: ‘td.Shortcut’ object has no attribute ‘time’ Context:/project1/script1_callbacks python >>>

ChatGPT

The error you’re seeing indicates that op.time.frame isn’t available in this context. The correct way to access the current frame number in TouchDesigner is to use me.time.frame or absTime.frame (depending on your needs). These are part of the global me object or absTime object that give access to timing information.

Here’s the corrected version of the script using absTime.frame:

import numpy as np

def onCook(scriptOp):
    # Clear any existing channels in scriptOp
    scriptOp.clear()

    # Get input CHOP
    inputCHOP = scriptOp.inputs[0]

    # Check if the "ty" channel exists in the input CHOP
    if 'ty' in [chan.name for chan in inputCHOP.chans()]:
        # Get the "ty" channel
        ty_channel = inputCHOP['ty']

        # Append the "ty" channel to the output
        scriptOp.appendChan('ty')

        # Convert the "ty" channel samples to a NumPy array for faster processing
        samples = np.array(ty_channel.vals)

        # Use the global absolute time for dynamic phase shifting
        time = absTime.frame  # Get the current frame number

        # Adjust the phase shift based on time
        phase_shift = (2 * np.pi) * (time * 0.01)  # Adjust 0.01 for speed of movement

        # Generate a sine wave with the phase shift
        num_samples = inputCHOP.numSamples
        sine_wave = np.sin(np.linspace(0, 2 * np.pi, num_samples) + phase_shift)

        # Randomize the frequency placement to reduce predictability
        random_indices = np.random.permutation(num_samples)  # Randomly shuffle indices
        randomized_frequencies = sine_wave[random_indices]  # Apply shuffle to sine wave

        # Blend random frequencies and sine pattern
        blend_factor = 0.6  # Adjust blend factor to control how much randomization vs sine
        blended_pattern = sine_wave * blend_factor + randomized_frequencies * (1 - blend_factor)

        # Sort the samples based on the blended pattern
        sorted_indices = np.argsort(blended_pattern)
        sorted_samples = samples[sorted_indices]

        # Assign the sorted samples back in one step
        scriptOp['ty'].vals = sorted_samples

    return

Key Change:

• absTime.frame: This gets the current frame number from the global absolute time in TouchDesigner. This will now give you the correct frame number, and allow you to introduce the phase shift dynamically.

This should solve the issue, and you should see the phase shift and randomness in effect. Let me know if it works as expected!