def counter_i_straight(lib=None): return CounterLine( ImaginaryPhrase(ImaginaryCell(rhythm=RHYTHM_STRAIGHT, pitches=( "R", 5, 0, -3, ), slug="straightup"), ImaginaryCell(rhythm=RHYTHM_STRAIGHT, pitches=(-3, -3, 0, -5), slug="straight"), slug="straight"), ImaginaryPhrase( ImaginaryCell(rhythm=RHYTHM_STRAIGHT, pitches=( "R", -5, -3, 2, ), slug="straightup_i"), ImaginaryCell( rhythm=RHYTHM_STRAIGHT, pitches=(0, -3, 2, 0), # first could also be rest slug="straight_i"), slug="straight_i"), slug="counter_i").autoname("phrases", "cells", prefix="counter_i")
def straight_bass( input_row, phrase_count=2, rhythm_tree=( (2, 2), (2, 2), ), input_start_beat=0, ): beat_counter = input_start_beat bass_line = ImaginaryLine() for i in range(phrase_count): bass_phrase = ImaginaryPhrase() for cell_r in rhythm_tree: bass_cell = ImaginaryCell() for r in cell_r: if r > 0: input_event = input_row.event_at_beat(beat_counter) # TO DO... think of being more flexifble to pull either cell/phrase, parent/grandparent input_node = input_event.parent.parent input_pitches = input_node.note_pitch_set my_pitch = chords.get_diatonic_root(input_pitches) - 24 else: my_pitch = "R" bass_cell.append(calliope.Event(beats=r, pitch=my_pitch)) beat_counter += abs(r) bass_phrase.append(bass_cell) bass_line.append(bass_phrase) return bass_line
def high_rhythm(lib=None): p = ImaginaryPhrase( ImaginaryCell(rhythm=(-0.5, 0.5) * 2 + (1, -1)), ImaginaryCell(rhythm=(1, ) + (-0.5, 0.5) * 3), ) p.note_events.setattrs(pitch=12) return p
def violins_speed_up(staff_name, pitch, intro_name=None): if intro_name: b2[staff_name].machine(lib(intro_name)) b2[staff_name].machine_arrow(ImaginaryCell(rhythm=(2,), pitches=(pitch,)).eps( 0,"pp", "\\<")(), pad_fill=False, arrow_beats=4, instruction="markup_column:repeat, speed up (not|necessary with others) until... ") b2[staff_name].machine_arrow(ImaginaryCell(rhythm=(0.5,0.5,), pitches=(pitch,pitch)).eps( 0, "mf")(), instruction="markup_column:...eventually matching woodblock's|eighth note pulse")
def bass_rhythm(lib=None): return ImaginaryPhrase( ImaginaryCell(rhythm=(1, 1, -1.5, 0.5), pitches=( -5, (-5, 4), "R", -1, )), ImaginaryCell(rhythm=(-2, 1, -1), pitches=("R", (-5, 5), "R")), )
def pad(self, beats=1, with_command=True): if beats > 0: floor_beats = math.floor(beats) remainder_beats = beats - floor_beats pad_cell = ImaginaryCell(rhythm=(1, ) * floor_beats, pitches=("S", ) * floor_beats) if remainder_beats: pad_cell.append( calliope.Event(beats=remainder_beats, pitch="S")) if with_command: pad_cell.events[0].tag("\\freePad") self.append(pad_cell) return pad_cell
def mid_rhythm(lib=None): return ImaginaryPhrase( ImaginaryCell(rhythm=(0.25, 0.25, 0.5, -0.5, 0.5, -1, 0.25, 0.25, 0.5)), ImaginaryCell(rhythm=( -1, 0.5, 0.5, -0.5, 0.5, 1, )), )
def weave(self, staff, index=0, **kwargs): pattern = abjad.CyclicTuple( (self.event_duration, ) * (self.dove_event_count + self.tail_event_count) + (0 - self.event_duration, ) * ((self.dove_event_count) * (self.dove_count - 1) - self.tail_event_count)) # abjac.CyclicTuple is unhappy about negative slice starts, so # reset offset if negative: if self.offset < 0: self.offset = self.offset % len(pattern) start_index = index * (self.dove_count - 1) * self.dove_event_count + self.offset my_rhythm = list( pattern[start_index:start_index + int(self.dovetail_duration / self.event_duration)]) # DO TO: THIS IS CONFUSING... document or rethink initial_tail_index = (start_index - self.dove_event_count) % len(pattern) if not self.tail_bookends[ 0] and initial_tail_index < self.tail_event_count: for i in range(self.tail_event_count - initial_tail_index): my_rhythm[i] = 0 - self.event_duration final_tail_index = start_index % len(pattern) if not self.tail_bookends[ 1] and final_tail_index <= self.tail_event_count: for i in range(final_tail_index): my_rhythm[0 - i - 1] = 0 - self.event_duration my_line = ImaginaryLine() cell_rhythm = [] last_rest = None for r in my_rhythm: my_is_rest = r < 0 if last_rest is not None and my_is_rest != last_rest: my_line.append(ImaginaryCell(rhythm=cell_rhythm)) cell_rhythm = [] cell_rhythm.append(r) last_rest = my_is_rest if cell_rhythm: my_line.append(ImaginaryCell(rhythm=cell_rhythm)) return my_line
def drum_dark(lib): c = ImaginaryCell(rhythm=( 0.25, 0.25, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.25, 0.25, ), pitches=( ( -8, -5, -1, ), -1, -1, -8, 5, -8, 4, -8, ( -5, 5, ), 4, )) c.events[0, 3, 5, 7].tag("note_head:0:cross") return c
def weave(self, staff, index=0, **kwargs): my_rhythm = [] my_stagger = self.swell_staggers[index % len(self.swell_staggers)] my_split_ratio = self.swell_split_ratios[index % len(self.swell_split_ratios)] if my_stagger[0] > 0: my_rhythm.append(0 - my_stagger[0]) # split duration rounded to nearest 16th note: my_rhythm.append( int((self.swell_duration - sum(my_stagger)) * my_split_ratio * 4) / 4) my_rhythm.append(self.swell_duration - sum(my_stagger) - my_rhythm[-1]) if my_stagger[1] > 0: my_rhythm.append(0 - my_stagger[1]) my_cell = ImaginaryCell(rhythm=my_rhythm) if self.low_dynamic: my_cell.note_events[0].tag(self.low_dynamic) if self.swell_dynamic: my_cell.note_events[1].tag(self.swell_dynamic) if self.low_dynamic and self.swell_dynamic: my_cell.note_events[0].tag("\\<") my_cell.note_events[1].tag("\\>") # my_cell.events[-1].tag("!<>\\pp") return my_cell
def arrow( self, beats=8, pad_beats=2, with_repeat=True, instruction="", text_length_on=False, ): arrow_cell = ImaginaryCell(rhythm=(1, ) * beats, pitches=("S", ) * beats) arrow_cell.events[0].tag("\\freeContinue") if with_repeat: arrow_cell.events[0].tag("\\bar \":|.\"") arrow_cell.events[1, -1].setattrs(rest=True) arrow_cell.events[1].tag("\\once \\hide Rest") arrow_cell.events[-1].tag("\\freePad", "\\freeRestArrow") if instruction: arrow_cell[0].tag(instruction) arrow_cell.events[0].tag( "\\once \\override TextScript.extra-offset = #'( 1 . 0 )") if text_length_on: arrow_cell.events[0].tag("\\textLengthOn") arrow_cell.events[-1].tag("\\textLengthOff") self.append(arrow_cell) if pad_beats: self.pad(pad_beats, with_command=False) return arrow_cell
def drum_rock_out(lib): c = ImaginaryCell(rhythm=( 0.5, 0.5, 0.5, 0.5, 0.5, 0.25, 0.25, 0.5, 0.5, ), pitches=( (-5, 9), (9, -8), (-5, 9, 2), (9, -8), (-5, 9), (9, 4, -8), 2, (-5, 9, 2), (9, -8), )) c.events[1, 3, 5, 8].tag("note_head:0:cross") c.events[0, 1, 2, 3, 4, 5, 7, 8].tag("note_head:-1:cross") return c
def high_rhythm_ii(lib=None): p = ImaginaryPhrase( ImaginaryCell(rhythm=(0.25, 0.25, 0.5, -0.5, 0.5, -0.5, 0.5, 0.25, 0.25, 0.5)), # ImaginaryCell(rhythm=(0.25,0.25, 0.5, -0.5, 0.5, -0.5, 0.5, -0.5, 0.5,)), ) p.note_events.setattrs(pitch=(0, 12)) return p
def counter(lib=None): return CounterLine(ImaginaryPhrase( ImaginaryCell(rhythm=RHYTHM_DOWN, pitches=( 0, -1, ), slug="down"), ImaginaryCell(rhythm=RHYTHM_MIST, pitches=(5, 4, -3), slug="mist"), slug="mistify", ), ImaginaryPhrase(ImaginaryCell(rhythm=RHYTHM_DOWN, pitches=( 5, 4, ), slug="down_i"), ImaginaryCell(rhythm=RHYTHM_MIST, pitches=(4, 9, 7), slug="mist_i"), slug="mistify_i"), ImaginaryPhrase(ImaginaryCell(rhythm=( -1, 2, 0.5, 0.5, ), pitches=( "R", 5, 4, 2, ), slug="fast"), ImaginaryCell(rhythm=(-0.5, 0.5, 0.5, 0.5, -2), pitches=(9, 9, 7, 5, "R"), slug="fast_i"), slug="fast"), ImaginaryPhrase(ImaginaryCell(rhythm=(-1, 1), pitches=("R", 7), slug="shortend"), ImaginaryCell(rhythm=( 0.5, 5.5, ), pitches=( 12, 9, ), slug="longend"), slug="end"), slug="counter").autoname("phrases", "cells", prefix="counter")
def shake_swell_arrow(seg, pitches, start_dynamic="p", end_dynamic="mp", *args, **kwargs): e_count = len(seg.events) + 1 seg.machine_arrow( ImaginaryCell(rhythm=(4, ), pitches=(pitches, )).eps(0, "tremolo:3")()) return seg.eps(e_count, e_count + 5, start_dynamic, "\\<")(e_count + 3, end_dynamic, "\\>")()
def drum_hits(lib): c = ImaginaryCell(rhythm=(1, -3), pitches=(( -8, -5, 2, 11, ), "R", "R", "R")) c.events[0].tag("note_head:0:cross") c.events[0].tag("note_head:3:cross") return c
def drum_on_off(lib): # TO DO: vary this up ... make it more interesting c = ImaginaryCell( rhythm=(0.5, ) * 4 + (0.5, 0.25, 0.25) + (0.5, 0.5) + (0.25, 0.25, 0.5) * 3 + (0.5, 0.25, 0.25), pitches=(-5, (-8, -5), 2, (-8), "R", (-8, 4), 4, 2, (-8, -5), (2, 9), 9, -8, (2, 9), 9, -8, 9, 9, -8, (9, 2), (-8, -5, 4), -1), ) c.events[1, 3, 5, 8, 11, 14, 17, 19].tag("note_head:0:cross") c.events[9, 10, 12, 13, 15, 16, 18].tag("note_head:-1:cross") return c
def fill_rests(self, beats=None, fill_to=None, **kwargs): segs = list(self.segments) segs_beats = [s.beats for s in segs] if fill_to: beats = beats or self.segments[fill_to].beats beats = beats or max(segs_beats) for seg, seg_beats in zip(segs, segs_beats): if seg_beats < beats: seg.append(ImaginaryCell(rhythm=(seg_beats - beats, )))
def rhythm1(lib): c1 = ImaginaryCell(rhythm=(0.25, 0.25, 0.5, 0.5, 0.5, -1, 0.25, 0.25, 0.5), pitches=((5, -5), 5, -8, (-5, 2, 4), -8, "R", 5, 4, (-1, -8))).eps(2, 4, 8, "note_head:0:cross")() c2 = ImaginaryCell(rhythm=( -1, 0.5, 0.5, 0.5, 0.5, 1, ), pitches=( "R", 9, (-8, 9), (-5, 2, 5), -8, 2, )).eps(1, 2, 4, "note_head:0:cross")(2, "note_head:1:cross")() return ImaginaryPhrase(c1, c2)
def gliss_up_block(rest_beats=-1, low_beats=3, high_beats=4, transpose=0, tags=()): return calliope.SegmentBlock( ImaginarySegment( ImaginaryCell( rhythm=(rest_beats, low_beats, high_beats), pitches=("R", 16 + transpose, 27 + transpose), respell="sharps", ).eps( 0, "speed up into tremolo", )(1, "!\\glissando :8", "\\<", *tags)(2, "ff", ":32")()))
def drum_quick_off2(lib): c = ImaginaryCell(rhythm=( 0.25, 0.25, 0.5, 1, 0.5, 0.25, 0.25, 0.5, 0.5, ), pitches=(9, 2, 2, -8, 9, 2, 2, (2, -5, -8), 9)) c.events[0, 3, 4, 7, 8].tag("note_head:0:cross") return c
def cell_shake(lib=None): return ImaginaryCell(rhythm=(2, 2, 1, 2, 1), pitches=( -11, (-11, -10), -10, (-11, -10), -11, )).eps( 0, "pp", "\\<", )(1, "tremolo:3")(2, "mp", "\\>")(3, "tremolo:3")( 4, "\\!", )()
def rhythm2(lib=None): c = ImaginaryCell(rhythm=( -0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, ), pitches=( "R", 9, 2, 9, "R", 9, 2, 9, )).eps(1, 3, 5, 7, "note_head:0:cross")() return ImaginaryPhrase(c, )
def drum_du_du(lib): c = ImaginaryCell( rhythm=(0.25, ) * 12 + (0.5, 0.5), pitches=( (-8, 5), 5, 5, 5, (-8, 4), 4, "R", 4, -8, 4, "R", 4, (-8, -1), (5, -1, 2), ), ) c.events[0, 4, 8, 16].tag("note_head:0:cross") return c
def drum_off_short(lib): c = ImaginaryCell( rhythm=( 0.25, 0.25, -0.5, ) + ( 0.5, 0.5, -1, 0.5, 0.5, ), pitches=( (-8, 9), 9, "R", ) + (9, -8, "R", 9, -8), ) c.note_events.tag("note_head:0:cross") c.note_events.tag("note_head:1:cross") return c
def drum_quick_off(lib): c = ImaginaryCell(rhythm=( 0.25, 0.25, 0.5, 1, 0.5, 0.25, 0.25, 1, ), pitches=( 9, 9, 9, -8, 9, 9, 9, -8, )) c.events.tag("note_head:0:cross") return c
def score1(lib): s = score.ImaginaryScore() sb = lib("integrate_block1") s = sb().annotate(slur_cells=True, label=( "phrases", "cells", )).to_score(s) # drum_off_cell.note_events[1].tag("brushes") # drum_on_off_cell.note_events.tag("note_head:0:cross") # drum_on_off_cell.note_events.tag("note_head:1:cross") drum_set = ImaginarySegment( lib("drum_on_off"), get_improv_line(rhythm=(1, ) * 8, times=7).ops("cells")(6, "\\<")(), get_improv_line(instruction="improv, solo", rhythm=(0.5, ) * 8, times=1).eps(0, "mf")(), ) s.staves["ooa_drum_set"].append(drum_set) string_staves = ( "ooa_violin1", "ooa_violin2", "ooa_cello1", "ooa_cello2", "cco_violin_i", "cco_violin_ii", "cco_viola", "cco_cello", ) s.extend_from( pulse_on_off_beat.PulseOnOffBeat( sb, fabric_staves=string_staves, phrase_beats=(8, ) * 8, ranges=pitch_ranges.LOW_TO_HIGHISH_RANGES, ), ) # CCO cello and viola come in first ... then for st in s.staves["ooa_cello1", "ooa_cello2"]: st.segments[0].mask("cells", 0, 1) for st in s.staves["cco_violin_i", "cco_violin_ii", ]: st.segments[0].mask( "cells", 0, 1, 2, 3, ) for st in s.staves["ooa_violin1", "ooa_violin2"]: st.segments[0].mask("cells", 0, 1, 2, 3, 4, 5) timp_seg = s.staves["cco_cello"].segments[0]() for n in timp_seg.note_events: if not n.pitch in (-22, -15, -10): n.pitch = "R" timp_seg.cells[12, 13].note_events.tag(">") timp_seg.transformed(calliope.StandardDurations()).eps( 0, "\\timpStaff", "timpani", "p")() s.staves["cco_percussion"].append(timp_seg) for st in s.staves[string_staves]: st.note_events[0].tag("arco", "p") st.phrases[3].e_smear_after(0, cover_notes=True, extend_beats=3.5).eps(0, "\\<")() st.cells[7].tag("mf") st.cells[13].e_smear_after(0, extend_beats=2.5, cover_notes=True).eps(0, "\\mp", "\\<")()() st.cells[13].eps(1, "mf", ">", ".")() st.cells[14].eps(0, ">", ".")() bass_seg = s.staves["cco_cello"].segments[0]() for n in bass_seg.cells[4:].note_events: n.pitch = sb.pitches_at(n.beats_before(bass_seg))[0] + 12 for c in bass_seg.cells[14:]: c.t(1) s.staves["cco_bass"].append(bass_seg) s.extend_from( lambda_segment.LambdaSegments( sb.with_only("bass_line", ), fabric_staves=("ooa_bassoon", "cco_bassoon"), funcs=( lambda x: x.crop_chords(indices=(0, 1)).crop("cells", 0, 1), lambda x: x.crop_chords(indices=(1, 0)).crop("cells", 0, 1), ), tag_all_note_events=("-", ))) s.extend_from( lambda_segment.LambdaSegments( sb.with_only("melody_line1"), fabric_staves=("harp1", "harp2"), funcs=( lambda x: x.crop_chords(indices=(1, )).ops("note_events") (0, "mp")(), lambda x: x.crop_chords(indices=(0, )).t(-12), ), )) # s.extend_from( # lambda_segment.LambdaSegments( # sb.with_only("counter_line"), # # assign_pitches_from_selectable = True, # fabric_staves = ("piano1","piano2"), # func = lambda x: x.transformed( # calliope.StandardDurations( # min_duration=0.25, # standard_duration=0.5,) # ).e_smear_after(4, cover_notes=True, extend_beats=1 # ).e_smear_after(6, cover_notes=True, extend_beats=0.5 # ).e_smear_after(8, cover_notes=True, extend_beats=0.5 # ).e_smear_after(10, cover_notes=True, extend_beats=0.5 # ).e_smear_after(16, cover_notes=True, extend_beats=0.5 # ).e_smear_after(19, cover_notes=True, extend_beats=0.5 # ).e_smear_after(22, cover_notes=True, extend_beats=0.5 # ).e_smear_after(29, cover_notes=True, extend_beats=0.5 # ).e_smear_after(33, cover_notes=True, extend_beats=0.5 # ).e_smear_after(35, cover_notes=True, extend_beats=0.5 # ).e_smear_after(46, cover_notes=True, extend_beats=0.5 # ).e_smear_after(86, cover_notes=True, extend_beats=0.5 # ).mask("events",24,25,27,31 # ).mask("cells",26,27,29,31).slur_cells(#).label("events","cells" # ), # funcs = ( # lambda x: x.crop_chords(indices=(1,)).transformed( # calliope.SmartRange( # smart_range = (12,26), # ) # ), # lambda x: x.crop_chords(indices=(0,)).t(-12).transformed( # ), # ) # ) # ) # harp_piano_combo = calliope.CompositeChordsLine( # calliope.LineBlock( # ImaginaryLine(*s.staves["harp2"].cells.copy()), # ImaginaryLine(*s.staves["piano2"].cells.copy())), # ).transformed(artics.GroupByBeats()) # s.staves["ooa_mallets"].append(ImaginarySegment(harp_piano_combo)) # s.extend_from( # lambda_segment.LambdaSegments( # sb.with_only("melody_line2"), # fabric_staves = ("piano1","piano2"), # funcs = ( # lambda x: x.crop_chords(indices=(1,)), # lambda x: x.crop_chords(indices=(0,)).t(-12), # ), # ) # ) guitars = osti.Osti( sb.with_only("bass_drones"), fabric_staves=( "ooa_bass_guitar", "ooa_guitar", ), ranges=pitch_ranges.MID_RANGES, osti_pulse_duration=1, osti_cell_length=16, osti_cell_count=4, ) s.extend_from( staggered_swell.StaggeredSwells( sb.with_only("high_drones"), fabric_staves=("ooa_flute", "cco_flute1", "cco_flute2"), low_dynamic="p", swell_dynamic="mf", swell_duration=8, cell_count=2, phrase_count=4, ), guitars, ) harp_lh = s.staves["harp2"].segments[0] for n in harp_lh.note_events: pitches_at_sb = sb.pitches_at(n.beats_before(harp_lh)) n.pitch = (pitches_at_sb[1], pitches_at_sb[-4]) harp_lh.smart_ranges([(-14, 4)]) # now remove dupes for n in harp_lh.note_events: n.pitch = set(n.pitch) for c in harp_lh.cells: c.mask("note_events", -1, -2) harp_lh.transformed(calliope.StandardDurations()) piano_rh = ImaginarySegment( ImaginaryLine( ImaginaryCell(rhythm=(-4, )), ImaginaryPhrase( ImaginaryCell(rhythm=(0.25, 1.75) * 2), ImaginaryCell(rhythm=(2, ) * 4), ) * 4, )) piano_lh = harp_lh() mallets = piano_rh() for n in mallets.note_events: n.pitch = sb.pitches_at(n.beats_before(mallets))[-3] s.staves["ooa_mallets"].append(mallets) mallets.eps(1, "mp")(8, 16, 22, 24, 30, ":32")() for n in piano_rh.note_events: if n.beats == 0.25: n.pitch = sb.pitches_at(n.beats_before(piano_rh))[-2] n.tag("(") elif n.beats == 1.75: n.pitch = sb.pitches_at(n.beats_before(piano_rh))[-1] n.tag(")") else: n.pitch = set(sb.pitches_at(n.beats_before(piano_rh))[-2:]) for n in piano_lh.note_events: n.pitch = sb.pitches_at(n.beats_before(piano_lh))[1] piano_lh.fuse().slur_cells() for n in piano_lh.note_events: n.pitch = set(sb.pitches_at(n.beats_before(piano_lh))[1:3]) s.staves["piano1"].append(piano_rh) s.staves["piano2"].append(piano_lh) s.fill_rests(beats=15 * 4) final_swell_sax_brass = swell_hit.SwellHit( sb.with_only("chords"), fabric_staves=instrument_groups.get_instruments( "sax", "brass", ), ranges=pitch_ranges.HIGHISH_RANGES, selectable_start_beat=15 * 4, low_dynamic="p", hit_dynamic="mf", swell_duration=7, hit_duration=1, hit_rest=0, hit_articulations=("-", )) s.extend_from(final_swell_sax_brass) s.fill_rests(beats=16 * 4) final_swell_winds_strings = swell_hit.SwellHit( sb.with_only("chords"), fabric_staves=instrument_groups.get_instruments( "winds", "strings", ), ranges=pitch_ranges.HIGHISH_RANGES, selectable_start_beat=16 * 4, low_dynamic="mp", hit_dynamic="f", swell_duration=3, hit_duration=1, hit_rest=0, hit_articulations=("-", )) s.extend_from(final_swell_winds_strings) # s.extend_from(final_block) s.fill_rests(fill_to="cco_violin_i") # s.only_staves("piano1", "piano2") # s.as_rhythm_and_short() # s.only_staves(*instrument_groups.get_instruments("cco_strings")) s.fill_rests() s.remove(s.staff_groups["short_score"]) # s.lines.apply(lambda x:x.auto_respell()) # s.phrases.apply(lambda x:x.auto_respell()) for staff in s.staves: # staff.phrases.transformed(calliope.Label()) # staff.lines.transformed(calliope.Label()) # TO DO: WHY DOESN'T THIS WORK????? if segs := staff.segments: main_seg = segs[0] for next_seg in list(segs[1:]): main_seg.extend(next_seg) next_seg.parent.remove(next_seg) main_seg.rehearsal_mark_number = 11 main_seg.compress_full_bar_rests = True
def sus_maker( input_row, inversions=(0, ), root_offsets=(0, ), # based on SCALE step (not chromatic pitch) allowed_thirds=None, # TO DO, consider dropping this rhythm=( 1, 1, 1, 1, ), input_t=0, truncate_to_input=True, input_start_beat=0, **kwargs): sus_interval_preference = (0, 4, 8, 3, 9, 7, 5, 2, 10, 1, 11, 6) # # TO DO MAYBE: could automate this... but worth it? # if prefer = "thirds": # sus_interval_preference = (0, 4, 8, 3, 9, 7, 5, 2, 10, 1, 11, 6) # else: # sus_interval_preference = (0, 4, 8, 3, 9, 7, 5, 2, 10, 1, 11, 6) cell_inventory = {} for select_attr, di in kwargs.items(): input_select = getattr(input_row, select_attr) for select_index, di2 in sorted(di.items()): input_node = input_select[select_index] input_beats_before = input_node.beats_before( input_row) - input_start_beat input_beats = input_node.beats my_input_t = di2.get("input_t", kwargs.get("input_t", input_t)) input_pitches = [p + my_input_t for p in input_node.note_pitch_set] input_chord_root = get_diatonic_root(input_pitches) my_scale = calliope.Scale(root=input_chord_root) my_root_offsets = di2.get("root_offsets", root_offsets) my_inversions = di2.get("inversions", inversions) my_rhythm = di2.get("rhythm", rhythm) my_allowed_thirds = di2.get("allowed_thirds", allowed_thirds) my_truncate_to_input = di2.get("truncate_to_input", truncate_to_input) my_octave_t = di2.get("octave", 0) * 12 beat_counter = 0 i = 0 # counting manually since only indexing note events sus_pitches = [] sus_rhythm = [] # print() # print(di2, input_beats, my_rhythm) while i < len(my_rhythm) and (beat_counter < input_beats or not truncate_to_input): # print(" ", beat_counter) my_beats = my_rhythm[i] if my_beats > 0: my_root_offset = my_root_offsets[i % len(my_root_offsets)] my_chord_root = my_scale[my_root_offset] my_inversion = my_inversions[i % len(my_inversions)] % 3 my_inverted_root = my_chord_root if my_inversion == 0 else my_chord_root + 12 input_event = input_row.event_at_beat(beat_counter + input_beats_before) input_pitches = input_event.note_pitch_set allowed_thirds = [ my_scale[i + 1 + my_root_offset] for i in range(3) ] my_sus = min(allowed_thirds, key=lambda x: sum([ sus_interval_preference.index( (x - p) % 12) for p in input_pitches ])) # print("ROOT:", allowed_thirds, my_sus) if my_inversion == 2: my_sus += 12 sus_pitches.append( sorted([ my_inverted_root + my_octave_t, my_sus + my_octave_t, my_scale[my_root_offset + 4] + my_octave_t ])) else: sus_pitches.append("R") if beat_counter + abs( my_beats) > input_beats and my_truncate_to_input: # print(beat_counter, input_beats) sus_rhythm.append(beat_counter - input_beats) else: sus_rhythm.append(my_beats) beat_counter += abs(my_beats) i += 1 # print(sus_rhythm) sus_cell = ImaginaryCell(rhythm=sus_rhythm, pitches=sus_pitches) # if i == 0: # print(input_beats_before, sus_cell) cell_inventory[input_beats_before] = sus_cell # print("-----------------------------------------------------") sus_line = ImaginaryLine() current_beats_before = 0 for beats_before, cell in sorted(cell_inventory.items()): if beats_before > current_beats_before: sus_line.append( ImaginaryCell(rhythm=(current_beats_before - beats_before, ))) current_beats_before += beats_before - current_beats_before sus_line.append(cell) # print(cell) # print("==========") current_beats_before += cell.beats # print(cell_inventory[0]) print("-----------------------------------------------------") # print(sus_line.cells) return sus_line
ImaginaryLine, ImaginaryPhrase, ImaginaryCell, ) from imaginary.stories import library # TO DO: consider using accent pattern # also TO DO: consider replacing these with auto sus generation (below) _OSTI_PITCHES = ( "R", (2, 5, 10), (2, 5, 10), (2, 5, 9), (4, 7, 12), ) _OSTI_2_CELL = ImaginaryCell(rhythm=(2, ), pitches=((5, 7, 12), )) _CHORD_PHRASE_1 = ImaginaryPhrase( ImaginaryCell(rhythm=(-0.5, 1, 0.5, 1, 1), pitches=_OSTI_PITCHES), _OSTI_2_CELL, ) _CHORD_PHRASE_2 = ImaginaryPhrase( ImaginaryCell(rhythm=(-0.5, 1, 1, 0.5, 1), pitches=_OSTI_PITCHES), _OSTI_2_CELL, ) def get_chord_phrase1(): return _CHORD_PHRASE_1()
def score2(lib): s = score.ImaginaryScore() sb = lib("rock_block2") s = sb().annotate(slur_cells=True, label=("phrases", "cells")).to_score(s) rim_shots = ImaginaryCell(rhythm=(1, 1, 1, 1), pitches=(2, 2, 2, 2)) rim_shots.note_events.tag("\\withSlash") drum_rhythm2 = lambda_segment.LambdaSegment( calliope.SegmentBlock( ImaginarySegment( lib("rock_rhythm2"), get_improv_line(times=8), rim_shots, get_improv_line(times=6), lib("drum_hits") * 3, )), fabric_staves=("ooa_drum_set", ), func=lambda x: x, ) cco_perc1 = osti.Osti(fabric_staves=("cco_percussion", ), osti_pulse_duration=0.5, osti_cell_length=8, osti_cell_count=9, func=lambda x: x.eps(0, "mf")()) cco_perc2 = lambda_segment.LambdaSegment( sb.with_only("high_rhythm"), fabric_staves=("cco_percussion", ), func=lambda x: x.with_only("cells", 9, 10, 11, 12, 13, 14, 15), ) cco_perc3 = osti.Osti(fabric_staves=("cco_percussion", ), osti_pulse_duration=0.5, osti_cell_length=8, osti_cell_count=3, func=lambda x: x.eps(0, "mf")()) cco_perc1.note_events.setattrs(pitch=0) cco_perc2.note_events.setattrs(pitch=0) cco_perc3.note_events.setattrs(pitch=0) cco_perc3.cells[-2].note_events[0].tag("\\<") cco_perc3.note_events[-1].tag("f") s.extend_from(cco_perc1, cco_perc2, cco_perc3) riffs_block = short_block.ChordsToSegmentBlock( selectable=sb.with_only("riff", ).segments[0], sort_chords=True, ) # TO DO: add ranges # ======================================================= trumpet_mute_outs = ImaginarySegment( ImaginaryCell(rhythm=(-4, )).eps(0, "mute out")()) s.staves["ooa_trumpet"].append(trumpet_mute_outs()) s.staves["cco_trumpet"].append(trumpet_mute_outs()) harp1_riff = lambda_segment.LambdaSegment( sb.with_only("riff", ), fabric_staves=("harp1", ), tag_events={0: ("mf", )}, func=lambda x: x, ) harp1_riff.cells[:16].setattrs(respell="sharps") # TO DO: model this pattern... already used multiple times! poke_harp1 = [] next_include = False for i, e in enumerate(harp1_riff.events): e_pitch = e.pitch if len(e_pitch) > 1 and abs(e_pitch[0] - e_pitch[1]) == 12: next_include = True poke_harp1.append(i) elif next_include: poke_harp1.append(i) next_include = False else: next_include = False harp1_riff.segments[0].poke("events", *poke_harp1) piano_riff = lambda_segment.LambdaSegment( sb.with_only("riff"), fabric_staves=( "piano1", "piano2", ), tag_all_note_events=(".", ), ranges=pitch_ranges.LOW_TO_HIGH_RANGES, assign_pitches_from_selectable=True, func=lambda x: x.eps(0, "bass")(), funcs=( lambda x: x.eps(40, "treble")(136, "8va")(151, "8va!")(), lambda x: x.eps(0, "8vb")(23, "8vb!")(112, "treble")(), )) piano_riff.staves["piano1"].note_events[-1].pitch += 12 piano_riff.staves["piano1"].phrases[:8].apply(lambda x: x.t(12)) piano_riff.staves["piano2"].phrases[8:].apply(lambda x: x.t(-12)) pizz = lambda_segment.LambdaSegment( sb.with_only("chords"), ranges=pitch_ranges.LOW_TO_HIGH_RANGES, fabric_staves=instrument_groups.get_instruments("cco_strings"), mask_staves=("cco_bass", ), assign_pitches_from_selectable=True, func=lambda x: x.transformed(calliope.StandardDurations())) pizz.staves["cco_viola"].note_events[0].tag("pizz") constant_pluck = osti.Osti( sb, fabric_staves=instrument_groups.get_instruments( "ooa_guitar", "ooa_strings"), ranges=pitch_ranges.LOW_TO_HIGH_RANGES, osti_pulse_duration=1, osti_cell_length=4, osti_cell_count=9, ) for st in constant_pluck.staves: st.segments[0].eps(0, "mf", "pizz, distorted")() s.extend_from( harp1_riff, piano_riff, pizz, drum_rhythm2, constant_pluck, ) # ======================================================= # BARS 1-6 opening_bass = lambda_segment.LambdaSegment( sb.with_only("bass_line"), assign_pitches_from_selectable=True, # ranges=pitch_ranges.PitchRanges(pitch_ranges.BOTTOM_SEQ), fabric_staves=("ooa_bassoon", "cco_bassoon", "ooa_trombone", "cco_trombone", "ooa_bass_guitar", "cco_bass"), # tag_events = {0:("mf", "pizz")}, # func = lambda x: x.only_first("cells",7).bookend_pad(0,3), # func = lambda x: x.crop("cells",1), func=lambda x: x.only_first("cells", 14).transformed( calliope.StandardDurations()), funcs=( lambda x: bass_artics(x), lambda x: bass_artics(x), lambda x: bass_artics(x.poke("cells", 7, 8, 10, 11)), lambda x: bass_artics(x.poke("cells", 7, 8, 10, 11)), lambda x: x, lambda x: x.eps(1, "pizz")(), )) for st in opening_bass.staves: st.note_events[0].tag("f") s.extend_from(opening_bass, ) # # ======================================================= wind_cloud_4_5 = lambda_segment.LambdaSegment( lib("rock_grid_g2_c4_5"), fabric_staves=( "ooa_flute", "cco_flute1", "cco_flute2", "ooa_clarinet", "cco_clarinet1", "cco_clarinet2", ), # tag_events = {0:("mp", "\\<",), 7:("mf",)}, # assign_pitches_from_selectable = True, # selectable_start_beat = 16*4, # func = lambda x: x.slur_cells().bookend_pad(2,3), # func = lambda x: x.crop("cells",1), bookend_beats=(7, 0), tag_all_note_events=("-", ), tag_events={ 0: ("mp", "\\<"), -1: (".", "f") }, func=lambda x: x, ) sax_opening_driving = driving_off.DrivingOff( sb, ranges=pitch_ranges.HIGH_TO_LOW_RANGES, fabric_staves=instrument_groups.get_instruments("sax", ), bookend_beats=(6, 3), ) s.extend_from( wind_cloud_4_5, sax_opening_driving, ) s.fill_rests(beats=7 * 4) # # ======================================================= cloud_16_17 = lib("rock_grid_g2_c16_17") wind_cloud_16_17 = lambda_segment.LambdaSegment( cloud_16_17, fabric_staves=( "ooa_flute", "ooa_clarinet", "ooa_alto_sax1", "ooa_alto_sax2", "ooa_tenor_sax", "ooa_bari_sax", ), tag_all_note_events=("-", ), tag_events={ 1: ("mp", "\\<"), -1: (".", "f") }, func=lambda x: x.bookend_pad(3, 0), ) brass_midpoint_driving = driving_off.DrivingOff( sb, selectable_start_beat=(7 * 4), ranges=pitch_ranges.MID_RANGES, fabric_staves=instrument_groups.get_instruments("brass", ), bookend_beats=(2, 0), ) s.extend_from( wind_cloud_16_17, brass_midpoint_driving, ) s.fill_rests(beats=9 * 4) # # ======================================================= # BAR 10+ # # ======================================================= mallets_improv1 = improv.Improv( sb, fabric_staves=("ooa_mallets", ), improv_times=3, ranges=pitch_ranges.HIGHISH_RANGES, selectable_start_beat=9 * 4, # pitch_selectable_indices = ( # (0,1,3,5), # ), ) mallets_improv2 = improv.Improv( sb, instruction="", fabric_staves=("ooa_mallets", ), improv_times=4, ranges=pitch_ranges.HIGHISH_RANGES, selectable_start_beat=12 * 4, # pitch_selectable_indices = ( # (0,2,4,5), # ), ) mallets_improv3 = improv.Improv( sb, instruction="", fabric_staves=("ooa_mallets", ), improv_times=3, ranges=pitch_ranges.HIGHISH_RANGES, selectable_start_beat=16 * 4, # pitch_selectable_indices = ( # (0,2,4,5), # ), ) s.extend_from(mallets_improv1, mallets_improv2, mallets_improv3) flute_high_swells = staggered_swell.StaggeredSwells( sb, low_dynamic="mp", swell_dynamic="mf", cell_count=1, phrase_count=5, swell_duration=8, selectable_start_beat=9 * 4, # swell_split_ratios = ( # 1/2, # ) swell_staggers=( (0, 4), (2, 2), (3, 1), # (0.5,0.5), # (1,0) ), fabric_staves=( "cco_flute1", "cco_flute2", "ooa_flute", ), ) s.extend_from(flute_high_swells, ) s.fill_rests(beats=12 * 4) # # ======================================================= cloud_26_31 = lib("rock_grid_g2_c26_31") wind_cloud_26_31 = lambda_segment.LambdaSegment( cloud_26_31, fabric_staves=( "ooa_clarinet", "ooa_alto_sax1", "ooa_alto_sax2", "ooa_tenor_sax", "ooa_bari_sax", "ooa_bassoon", ), tag_all_note_events=("-", ), tag_events={ 0: ("mf", "\\<"), -1: (".", "f") }, bookend_beats=(3, 1)) s.extend_from(wind_cloud_26_31, ) # # ======================================================= # BAR 16+ # s.fill_rests(beats=15*4) hits_final = lambda_segment.LambdaSegment( sb.with_only("chords"), ranges=pitch_ranges.HIGHISH_TO_MID_RANGES, fabric_staves=instrument_groups.get_instruments( "ooa_brass", "ooa_strings") + ("ooa_guitar", "ooa_bass_guitar"), assign_pitches_from_selectable=True, selectable_start_beat=15 * 4, func=lambda x: x.with_only("cells", 32, 33).bookend_pad(3, 1), tag_all_note_events=(">", )) for st in hits_final.staves["ooa_violin1", "ooa_violin2", "ooa_cello1", "ooa_cello2"]: st.note_events[0].tag("arco, distorted") s.extend_from(hits_final) s.fill_rests(beats=16 * 4) strings_improv = improv.Improv( sb.with_only("high_drones"), fabric_staves=instrument_groups.get_instruments("ooa_strings", ), improv_times=3, ranges=pitch_ranges.HIGHISH_RANGES, selectable_start_beat=16 * 4, ) s.extend_from(strings_improv) # # ======================================================= # adjust for bass 8va for bass_seg in s.staves["cco_bass"].segments: bass_seg.transformed(calliope.Transpose(interval=12)) s.fill_rests() # s.remove(s.staff_groups["short_score"]) for staff in s.staves: # staff.phrases.transformed(calliope.Label()) # staff.lines.transformed(calliope.Label()) if segs := staff.segments: main_seg = segs[0] for next_seg in list(segs[1:]): main_seg.extend(next_seg) next_seg.parent.remove(next_seg) main_seg.rehearsal_mark_number = 8 main_seg.compress_full_bar_rests = True