Minim 14. balance Example

A Balance UGen can change the magnitude of left or right channel in a stereo signal.

We use a LFO and Sine Oscillator as well.

---

# Ex14.pyde
# Based on Java File in Examples: balanceExample.pde

'''
balanceExample is an example of using the Balance UGen
inside an instrument. It is important to note that
Balance works specifically on stereo signals. It is
not the same as Pan, which takes a mono signal and
places it in a stereo field. Balance works by simply
attenuating either the left or right channel of a
stereo signal based on what the balance is set to.
Negative balance values will attenuate the left channel
and positive balance values attentuate the right channel.
For more information about Minim and additional features,
visit http://code.compartmental.net/minim/
author: Damien Di Fede
'''

add_library('minim')

out = None

# Every instrument must implement the Instrument interface
# so playNote() can call the instrument's methods.
class ToneInstrument(Instrument):
    # declare our oscillators. sineOsc is used for the
    # sounding tone and lFOOsc is used to control the
    # value of Balance
    def __init__(self, frequency, amplitude, lfoFrequency,
                 lfoAmplitude):
        self.sineOsc = Oscil(frequency, amplitude,
                            Waves.SINE)
        self.lFOOsc = Oscil(lfoFrequency, lfoAmplitude,
                            Waves.SINE)
        # Balance takes the value of the Balance as an
        # argument. 0 would result in no change in the
        # signal fed into it
        # negative values will attenuate the left channel
        # and positive values will attenuate the right
        # channel
        self.balance = Balance(0.5)
        # patch our LFO to the balance control of Balance
        self.lFOOsc.patch(self.balance.balance)
        # patch our oscillator to the balance and into the
        # damp
        self.sineOsc.patch(self.balance)
        
    def noteOn(self,dur):
        # every instrument must have a noteOn(float)
        # method to start sounding we simply patch
        # our balance to output. This is better than
        # simply turning the volume up because
        # it means we don't actually have to do any
        # processing until we are meant to be heard.
        self.balance.patch(out)
        
    def noteOff(self):
        # every instrument must have a noteOff() method
        self.balance.unpatch(out)

def setup():
    # initalize the drawing window
    global out
    size(512, 200)
    # initalize the minim object and output
    minim = Minim(this)
    # note that we must ask for a stereo output
    # because balance does not work with mono output.
    out = minim.getLineOut(Minim.STEREO, 1024)
    # pause time when adding a bunch of notes at once
    out.pauseNotes()
    # make an instance of my instrument and ask the
    # output to play it
    # arguments are: oscillator frequency, oscillator
    # amplitude, lfo for the balance frequency, lfo
    # for the balance amplitude
    myNote = ToneInstrument(200.0, 0.3, 0.5, 1.0)
    # play this instrument on the output.
    # arguments are: how many seconds from now to
    # play the note, and how long to play the note for
    out.playNote(0.0, 8.0, myNote)
    # make another instance of my instrument
    myNote = ToneInstrument(415.3, 0.3, 1.0, 1.0)
    out.playNote(2.0, 0.5, myNote)
    myNote = ToneInstrument(415.3, 0.3, 2.0, 1.0)
    out.playNote(3.5, 0.5, myNote)
    myNote = ToneInstrument(415.3, 0.3, 3.0, 1.0)
    out.playNote(5.0, 0.5, myNote)
    myNote = ToneInstrument(830.6, 0.3, 5.0, 1.0)
    out.playNote(6.5, 1.5, myNote)
    # resume time after a bunch of notes are added
    # at once
    out.resumeNotes()
    
# draw is run many times
def draw():
    # erase the window to black
    background(0)
    # draw using a white stroke
    stroke(255)
    # draw the waveforms
    for i in range(out.bufferSize() - 1):
        # find the x position of each buffer value
        x1  =  map(i, 0, out.bufferSize(), 0, width)
        x2  =  map(i+1, 0, out.bufferSize(), 0, width)
        # draw a line from one buffer position to the next
        # for both channels
        line(x1, 50 + out.left.get(i)*50,
             x2, 50 + out.left.get(i+1)*50)
        line(x1, 150 + out.right.get(i)*50,
             x2, 150 + out.right.get(i+1)*50)

---

This is the output:

---