composers

Abstract base class

class roqba.composers.abstract_composer.AbstractComposer(gateway, settings, behaviour, scale='DIATONIC')

static assemble_real_scale(scale, min=0, max=128, tunings=None)

extends the one-octave scale over the specified range.

Tunings should be in (<index>, <delta>) format, e.g. {1: -0.5 2: -1} would create the the start of a greek enharmonic scale for an underlying scale of [1, 1, 1,.....

choose_rhythm()

generate()

generate_real_scale(min=0, max=128)

extends the one-octave scale over the specified range

report()

utility function that prints info on harmonies and single voices

set_binaural_diffs(val=None, voice=None)

“de-tunes” the specified voice by the specified interval (in hertz)

if no values are given, random values (in the configurated range) are set for each voice.

set_meter(meter)

modifies composer-attributes for the specified meter.

calls reload_register method of the voices and creates and sets the new meter also for the drummer-instance

set_scale(name, min=0, max=128)

sets the specified scale and generates a new real scale

Amadinda

class roqba.composers.amadinda.Composer(gateway, settings, behaviour, scale='DIATONIC')

all_python_words()

choose_rhythm()

generate(state)

main generating function, the next polyphonic step is produced here

any of the voices can change.

make_new_pattern()

next_voice_note(voice, meter_pos)

shift_pattern(seq1, seq2, offset)

Baroq

class roqba.composers.baroq.Composer(gateway, settings, behaviour)

acceptable_harm_for_length(harm, length)

checks if the specified (interval-set) are “harmonic”

acceptable_harmony(chord)

checks if a chord is “harmonic”

add_duration_in_msec(state)

adds duration in milliseconds for each note in self.voices

apply_scale()

sets the real note for the scale-bound notes in each voice

embellish(state)

checks for embellishment markers of the single voices

• starts a thread to handle the embellishment

static flatten_chord(chord)

maps a specified code to the base octave

generate(state)

main generating function, the next polyphonic step is produced here

any of the voices can change.

static get_deltas(chord)

returns an array of the intervals between the specified notes

is_base_harmony(chord)

checks if a chord is a the base tonality

(either major or minor) of the current context

ornament_handler(v, duration, note, note_delta, state)

this method handles the sending of the ornament notes.

the ornament is chosen randomly if the ornament would be too fast, it returns without action

static scale_walker(scale, present_note, delta)

walks the <scale> <delta> steps starting at <present_note>

sort_voices_by_importance(by='imp')

sorts the voices according to their importance.

by: ‘imp’:

• importance according to register

by: ‘dir’:

• voices having a registered direction first

stream_analyzer()

analyses the stream of notes.

searches for target-harmonies and sets a flag

Rendezvous

class roqba.composers.rendezvous.Composer(gateway, settings, behaviour, scale='HARMONIC')

determine_rendezvous_transition(voice=None)

generate(state)

main generating function, the next polyphonic step is produced here.

next_voice_note(voice)

return the next note for a voice if it is the correct tick

select_next_anchor_tick(sendout_offset=0)

set the next send-out and and rendezvous ticks

select_next_harmony()

select the next rendezvous’s harmony

roqba.composers.rendezvous.random() → x in the interval [0, 1).