Example #1
0
def check_manuals_ranges(score):
    manuals_voice_1 = score['Manuals Voice 1']
    manuals_voice_2 = score['Manuals Voice 2']
    rh_manual_range = abjad.pitchtools.PitchRange('[-20, 43]')
    lh_manual_range = abjad.pitchtools.PitchRange('[-32, 25]')
    lh_total = 0
    lh_violations = 0
    for note in abjad.iterate(manuals_voice_1).by_class(abjad.Note):
        lh_total += 1
        if note not in lh_manual_range:
            lh_violations += 1
            abjad.label(note).color_leaves('red')
    #message = '{} of {} lh pitches out of range.'
    #message = message.format(lh_violations, lh_total)
    #print(message)
    rh_total = 0
    rh_violations = 0
    for note in abjad.iterate(manuals_voice_2).by_class(abjad.Note):
        rh_total += 1
        if note not in rh_manual_range:
            rh_violations += 1
    #message = '{} of {} rh pitches out of range.'
    #message = message.format(rh_violations, rh_total)
    #print(message)
    if lh_violations or rh_violations:
        #message = 'pitches out of range!'
        #raise Exception(message)
        #print(message)
        pass
Example #2
0
def test_scoretools_Iteration__depth_first_03():
    r'''Duplicates-allowed depth-first search: nodes yield every time they are
    traversed.  '''

    # LEFT-TO-RIGHT #

    iterator = abjad.iterate(staff[2])._depth_first(unique=False, )

    assert next(iterator) is staff[2]
    assert next(iterator) is staff[2][0]
    assert next(iterator) is staff[2][0][0]
    assert next(iterator) is staff[2][0]
    assert next(iterator) is staff[2][0][1]
    assert next(iterator) is staff[2][0]
    assert next(iterator) is staff[2]
    assert next(iterator) is staff[2][1]
    assert next(iterator) is staff[2][1][0]
    assert next(iterator) is staff[2][1]
    assert next(iterator) is staff[2][1][1]
    assert next(iterator) is staff[2][1]
    assert next(iterator) is staff[2]
    assert pytest.raises(StopIteration, 'next(iterator)')
    r'''
    abjad.Container(abjad.Voice(d'8, ef'8), abjad.Voice(e'8, f'8))
    Voice(d'8, ef'8)
    d'8
    Voice(d'8, ef'8)
    ef'8
    Voice(d'8, ef'8)
    abjad.Container(abjad.Voice(d'8, ef'8), abjad.Voice(e'8, f'8))
    Voice(e'8, f'8)
    e'8
    Voice(e'8, f'8)
    f'8
    Voice(e'8, f'8)
    abjad.Container(abjad.Voice(d'8, ef'8), abjad.Voice(e'8, f'8))
    '''

    # RIGHT-TO-LEFT #

    iterator = abjad.iterate(staff[2])._depth_first(
        direction=abjad.Right,
        unique=False,
    )

    assert next(iterator) is staff[2]
    assert next(iterator) is staff[2][1]
    assert next(iterator) is staff[2][1][1]
    assert next(iterator) is staff[2][1]
    assert next(iterator) is staff[2][1][0]
    assert next(iterator) is staff[2][1]
    assert next(iterator) is staff[2]
    assert next(iterator) is staff[2][0]
    assert next(iterator) is staff[2][0][1]
    assert next(iterator) is staff[2][0]
    assert next(iterator) is staff[2][0][0]
    assert next(iterator) is staff[2][0]
    assert next(iterator) is staff[2]
    assert pytest.raises(StopIteration, 'next(iterator)')
    r'''
Example #3
0
    def comment_measure_numbers(score):
        """
        Comments measure numbers in ``score``.
        """
        import abjad

        offset_to_measure_number = {}
        for context in abjad.iterate(score).components(abjad.Context):
            if not context.simultaneous:
                break
        site = "abjad.SegmentMaker.comment_measure_numbers()"
        measures = abjad.select(context).leaves().group_by_measure()
        for i, measure in enumerate(measures):
            measure_number = i + 1
            first_leaf = abjad.select(measure).leaf(0)
            start_offset = abjad.inspect(first_leaf).timespan().start_offset
            offset_to_measure_number[start_offset] = measure_number
        for leaf in abjad.iterate(score).leaves():
            offset = abjad.inspect(leaf).timespan().start_offset
            measure_number = offset_to_measure_number.get(offset, None)
            if measure_number is None:
                continue
            context = abjad.inspect(leaf).parentage().get(abjad.Context)
            if context.name is None:
                string = (
                    f"% [{context.lilypond_type} measure {measure_number}]")
            else:
                string = f"% [{context.name} measure {measure_number}]"
            literal = abjad.LilyPondLiteral(string, "absolute_before")
            tag = abjad.Tag("COMMENT_MEASURE_NUMBERS").append(site)
            abjad.attach(literal, leaf, tag=tag)
    def _handle_voice(self, voice, current_stage):
        # hide all noteheads if no fingerings.py
        if self._fingerings is None or self._fingerings[current_stage] is None:
            for note in abjad.iterate(voice).by_leaf():
                self._hide_note_head(note)
            return
        # get logical ties and construct left_hand tablature
        previous_fingering = None
        for logical_tie in abjad.iterate(voice).by_logical_tie():
            if logical_tie.is_pitched:
                fingering_index = WoodwindFingeringHandler._cycle_next(
                    self._fingering_patterns,
                    current_stage
                )

                fingering = self._fingerings[current_stage][fingering_index]

                self._construct_fingering_tablature(
                    logical_tie=logical_tie,
                    fingering=fingering,
                    previous_fingering=previous_fingering,
                )

                previous_fingering = fingering
            else:
                previous_fingering = None
Example #5
0
def test_scoretools_Iteration__depth_first_06():
    r'''Uncapped and restricted depth-first search.
    '''

    # LEFT-TO-RIGHT #

    iterator = abjad.iterate(staff[2])._depth_first(
        capped=False,
        forbid='simultaneous',
    )

    assert next(iterator) is staff[2]
    assert next(iterator) is staff
    assert next(iterator) is staff[3]
    assert next(iterator) is staff[4]
    r'''
    abjad.Container(abjad.Voice(d'8, ef'8), abjad.Voice(e'8, f'8))
    Staff{5}
    fs'8
    iterator'8
    '''

    # RIGHT-TO-LEFT #

    iterator = abjad.iterate(staff[2])._depth_first(
        capped=False,
        direction=abjad.Right,
        forbid='simultaneous',
    )

    assert next(iterator) is staff[2]
    assert next(iterator) is staff
    assert next(iterator) is staff[1]
    assert next(iterator) is staff[0]
    r'''
Example #6
0
    def comment_measure_numbers(score):
        """
        Comments measure numbers in ``score``.
        """
        import abjad

        offset_to_measure_number = {}
        for context in abjad.iterate(score).components(abjad.Context):
            if not context.is_simultaneous:
                break
        measures = abjad.select(context).leaves().group_by_measure()
        for i, measure in enumerate(measures):
            measure_number = i + 1
            first_leaf = abjad.select(measure).leaf(0)
            start_offset = abjad.inspect(first_leaf).timespan().start_offset
            offset_to_measure_number[start_offset] = measure_number
        for leaf in abjad.iterate(score).leaves():
            offset = abjad.inspect(leaf).timespan().start_offset
            measure_number = offset_to_measure_number.get(offset, None)
            if measure_number is None:
                continue
            context = abjad.inspect(leaf).parentage().get(abjad.Context)
            if context.name is None:
                string = (
                    f"% [{context.lilypond_type} measure {measure_number}]"
                )
            else:
                string = f"% [{context.name} measure {measure_number}]"
            literal = abjad.LilyPondLiteral(string, "absolute_before")
            abjad.attach(literal, leaf, tag="COMMENT_MEASURE_NUMBERS")
Example #7
0
    def __call__(self, segment_maker):
        r'''Calls spacing specifier.

        Returns none.
        '''
        score = segment_maker._score
        skip_context = score['Time Signature Context Skips']
        leaves = abjad.iterate(score).by_leaf()
        minimum_leaf_durations_by_measure = \
            self._get_minimum_leaf_durations_by_measure(skip_context, leaves)
        fermata_start_offsets = getattr(
            segment_maker,
            '_fermata_start_offsets',
            [],
            )
        skips = abjad.iterate(skip_context).by_leaf(abjad.scoretools.Skip)
        for measure_index, skip in enumerate(skips):
            measure_timespan = abjad.inspect_(skip).get_timespan()
            if (self.fermata_measure_width is not None and
                measure_timespan.start_offset in fermata_start_offsets):
                duration = self.fermata_measure_width
            else:
                duration = minimum_leaf_durations_by_measure[measure_index]
                if self.minimum_width is not None:
                    if self.minimum_width < duration:
                        duration = self.minimum_width
                if self.multiplier is not None:
                    duration = duration / self.multiplier
            command = abjad.indicatortools.LilyPondCommand('newSpacingSection')
            abjad.attach(command, skip)
            moment = abjad.schemetools.SchemeMoment(duration)
            abjad.set_(skip).score.proportional_notation_duration = moment
Example #8
0
    def _populate_time_signature_contexts(self):
        r""" Makes and inserts blank measures for time signature context and
        attaches tempo indicators.
        """
        for staff in abjad.iterate(self._score).by_class(abjad.Context):
            # if staff.name is 'Separator':
            #     measures = self._make_skip_filled_measures()
            #     staff.extend(measures)
            if staff.context_name == 'TimeSignatureContext':
                if self._ruler:
                    measures = self._make_repeated_note_measures()
                else:
                    measures = self._make_skip_filled_measures()

                # attach Tempi
                for tempo in self.tempo_map:
                    if tempo[0] < len(measures):
                        abjad.attach(tempo[1], measures[tempo[0]][0])

                # attach dummy first bar command
                leaves = abjad.iterate(measures).by_class(abjad.Leaf)
                leaves = list(leaves)
                first_leaf = leaves[0]
                dummy_first_bar_command = abjad.indicatortools.LilyPondCommand(
                    'bar ""'
                )
                abjad.attach(dummy_first_bar_command, first_leaf)

                voice = abjad.Voice(measures)
                staff.append(voice)
Example #9
0
 def apply_pitches(containers, pitched_notes):
     pitch_index = 0
     #leaves = abjad.iterate(containers).leaves()
     leaves = abjad.iterate(containers).leaves(grace_notes=False)
     for leaf_index, leaf in enumerate(leaves):
         if not isinstance(leaf, abjad.Note):
             continue
         if leaf_index == 603:
             pitch_index += 1
         pitched_note = pitched_notes[pitch_index]
         written_pitch = pitched_note.written_pitch
         leaf.written_pitch = written_pitch
         if written_pitch == -1:
             abjad.label(leaf).color_leaves('green')
         pitch_index += 1
         inspection = abjad.inspect(leaf)
         grace_container = inspection.grace_container()
         if not grace_container:
             continue
         for grace_container in [grace_container]:
             agent = abjad.iterate(grace_container)
             for note in agent.leaves(pitched=True):
                 pitched_note = pitched_notes[pitch_index]
                 written_pitch = pitched_note.written_pitch
                 note.written_pitch = written_pitch
                 pitch_index += 1
Example #10
0
def test_scoretools_Iteration__depth_first_07():
    r'''Restricted depth-first search with duplicates allowed.
    '''

    # LEFT-TO-RIGHT

    iterator = abjad.iterate(staff)._depth_first(
        forbid='simultaneous',
        unique=False,
    )

    assert next(iterator) is staff
    assert next(iterator) is staff[0]
    assert next(iterator) is staff
    assert next(iterator) is staff[1]
    assert next(iterator) is staff
    assert next(iterator) is staff[2]
    assert next(iterator) is staff
    assert next(iterator) is staff[3]
    assert next(iterator) is staff
    assert next(iterator) is staff[4]
    assert next(iterator) is staff
    assert pytest.raises(StopIteration, 'next(iterator)')
    r'''
    Staff{5}
    c'8
    Staff{5}
    cs'8
    Staff{5}
    abjad.Container(abjad.Voice(d'8, ef'8), abjad.Voice(e'8, f'8))
    Staff{5}
    fs'8
    Staff{5}
    iterator'8
    Staff{5}
    '''

    # RIGHT-TO-LEFT #

    iterator = abjad.iterate(staff)._depth_first(
        direction=abjad.Right,
        forbid='simultaneous',
        unique=False,
    )

    assert next(iterator) is staff
    assert next(iterator) is staff[4]
    assert next(iterator) is staff
    assert next(iterator) is staff[3]
    assert next(iterator) is staff
    assert next(iterator) is staff[2]
    assert next(iterator) is staff
    assert next(iterator) is staff[1]
    assert next(iterator) is staff
    assert next(iterator) is staff[0]
    assert next(iterator) is staff
    assert pytest.raises(StopIteration, 'next(iterator)')
    r'''
def test_scoretools_VerticalMoment___hash___01():
    r'''Vertical moments behave well when included in a set.
    '''

    staff = abjad.Staff("c'8 d'8 e'8 f'8")
    vms = []
    vms.extend(abjad.iterate(staff).vertical_moments())
    vms.extend(abjad.iterate(staff).vertical_moments())

    assert len(vms) == 8
    assert len(set(vms)) == 4
Example #12
0
 def _iterate_logical_ties(voice):
     i = -1
     count = len(list(abjad.iterate(voice).by_logical_tie()))
     for tie in abjad.iterate(voice).by_logical_tie():
         start_moment = abjad.inspect(
             tie.head
         ).get_vertical_moment(voice)
         offset_start = float(start_moment.offset)
         offset_end = offset_start + float(tie.get_duration())
         i += 1
         yield tie, offset_start, offset_end, i, count
Example #13
0
def test_scoretools_Iteration__depth_first_02():
    r'''Uncapped depth-first search: uncapped iteration returns
    all elements above self._client
    '''

    # LEFT-TO-RIGHT #

    iterator = abjad.iterate(staff[2])._depth_first(capped=False, )

    assert next(iterator) is staff[2]
    assert next(iterator) is staff[2][0]
    assert next(iterator) is staff[2][0][0]
    assert next(iterator) is staff[2][0][1]
    assert next(iterator) is staff[2][1]
    assert next(iterator) is staff[2][1][0]
    assert next(iterator) is staff[2][1][1]
    assert next(iterator) is staff
    assert next(iterator) is staff[3]
    assert next(iterator) is staff[4]
    assert pytest.raises(StopIteration, 'next(iterator)')
    r'''
    abjad.Container(abjad.Voice(d'8, ef'8), abjad.Voice(e'8, f'8))
    Voice(d'8, ef'8)
    d'8
    ef'8
    Voice(e'8, f'8)
    e'8
    f'8
    Staff{5}
    fs'8
    iterator'8
    '''

    # RIGHT-TO-LEFT #

    iterator = abjad.iterate(staff[2])._depth_first(
        capped=False,
        direction=abjad.Right,
    )

    assert next(iterator) is staff[2]
    assert next(iterator) is staff[2][1]
    assert next(iterator) is staff[2][1][1]
    assert next(iterator) is staff[2][1][0]
    assert next(iterator) is staff[2][0]
    assert next(iterator) is staff[2][0][1]
    assert next(iterator) is staff[2][0][0]
    assert next(iterator) is staff
    assert next(iterator) is staff[1]
    assert next(iterator) is staff[0]
    assert pytest.raises(StopIteration, 'next(iterator)')
    r'''
def test_make_measures_01():

    t = abjad.Voice([abjad.Note(n, (1, 8)) for n in range(8)])
    assert len(t) == 8
    leaves_before = abjad.iterate(t).by_leaf()
    leaves_before = list(leaves_before)
    lidercfeny.etc.transforms.make_measures(t, [(n, 8) for n in (2, 2, 2, 2)])
    assert len(t) == 4
    leaves_after = abjad.iterate(t).by_leaf()
    leaves_after = list(leaves_after)
    assert leaves_before == leaves_after
    for x in t:
        assert isinstance(x, abjad.Measure)
        assert abjad.inspect_(x).get_duration() == abjad.Duration(2, 8)
def set_articulations(voice, articulations, *args, **kwargs):
    r"""Iterates leaves and sets articulations.
    """
    leaves = abjad.iterate(voice).by_leaf()
    leaves = list(leaves)
    if len(args) == 0:
        start = 0
        stop = len(leaves)
    elif len(args) == 1:
        start = stop = args
    elif len(args) == 2:
        start, stop = args
    else:
        raise ValueError
    leafSlice = leaves[start : stop + 1]
    if kwargs.has_key("exclude"):
        exclude = kwargs["exclude"]
    else:
        exclude = True
    for l in leafSlice:
        if instance(l, (Note, Chord)) or not exclude:
            if isinstance(articulations, str):
                l.articulations = [articulations]
            elif isinstance(articulations, list):
                l.articulations = articulations
            else:
                raise ValueError
 def __illustrate__(self):
     score = self()
     time_signatures = [
         (3, 4), (7, 8), (2, 4), (5, 16),
         (4, 4), (6, 8), (5, 4), (3, 8),
         (3, 4), (7, 8), (2, 4), (5, 16),
         ]
     for voice in iterate(score).by_class(abjad.Voice):
         for pair in time_signatures:
             rest = abjad.MultimeasureRest(1)
             attach(Multiplier(pair), rest)
             voice.append(rest)
     for pair in time_signatures:
         skip = abjad.Skip(1)
         attach(Multiplier(pair), skip)
         score['Time Signature Context'].append(skip)
         attach(
             abjad.TimeSignature(pair),
             skip,
             scope=abjad.Score,
             )
     module = importlib.import_module(type(self).__module__)
     score_path = pathlib.Path(module.__file__).parent.parent
     stylesheet_path = score_path.joinpath('stylesheets', 'stylesheet.ily')
     stylesheet_path = stylesheet_path.resolve()
     lilypond_file = lilypondfiletools.LilyPondFile.new(
         score,
         includes=[str(stylesheet_path)],
         use_relative_includes=True,
         )
     return lilypond_file
Example #17
0
    def _attach_rhythm_annotation_spanner(self, selection):
        from . import piecewise

        if not self.annotation_spanner_text and not self.frame:
            return
        leaves = []
        for leaf in abjad.iterate(selection).leaves():
            if abjad.get.parentage(leaf).get(abjad.OnBeatGraceContainer):
                continue
            leaves.append(leaf)
        container = abjad.get.before_grace_container(leaves[0])
        if container is not None:
            leaves_ = abjad.select(container).leaves()
            leaves[0:0] = leaves_
        container = abjad.get.after_grace_container(leaves[-1])
        if container is not None:
            leaves_ = abjad.select(container).leaves()
            leaves.extend(leaves_)
        string = self.annotation_spanner_text
        if string is None:
            string = self._make_rhythm_annotation_string()
        color = self.annotation_spanner_color or "#darkyellow"
        command = piecewise.rhythm_annotation_spanner(
            string,
            abjad.tweak(color).color,
            abjad.tweak(8).staff_padding,
            leak_spanner_stop=True,
            selector=classes.select().leaves(),
        )
        command(leaves)
    def check_out_of_range_notes(self, argument=None):
        r'''Checks out-of-range notes.

        ..  container:: example

            Out of range:

            >>> staff = abjad.Staff("c'8 r8 <d fs>8 r8")
            >>> violin = abjad.Violin()
            >>> abjad.attach(violin, staff[0])
            >>> abjad.show(staff) # doctest: +SKIP

            ..  docs::

                >>> abjad.f(staff)
                \new Staff
                {
                    \set Staff.instrumentName = \markup { Violin }
                    \set Staff.shortInstrumentName = \markup { Vn. }
                    c'8
                    r8
                    <d fs>8
                    r8
                }

            >>> agent = abjad.inspect(staff)
            >>> print(agent.tabulate_wellformedness())
            0 /	0 beamed long notes
            0 /	0 discontiguous spanners
            0 /	5 duplicate ids
            0 /	1 empty containers
            0 /	0 misdurated measures
            0 /	0 misfilled measures
            0 /	0 mismatched enchained hairpins
            0 / 0 mispitched ties
            0 /	4 misrepresented flags
            0 /	5 missing parents
            0 /	0 nested measures
            0 /	4 notes on wrong clef
            1 /	2 out of range notes
            0 /	0 overlapping beams
            0 /	0 overlapping glissandi
            0 /	0 overlapping hairpins
            0 /	0 overlapping octavation spanners
            0 /	0 overlapping ties
            0 / 0 overlapping trill spanners
            0 /	2 tied rests

        Returns true or false.
        '''
        import abjad
        violators, total = [], set()
        for leaf in abjad.iterate(argument).leaves(pitched=True):
            total.add(leaf)
            instrument = abjad.inspect(leaf).get_effective(abjad.Instrument)
            if instrument is None:
                continue
            if leaf not in instrument.pitch_range:
                violators.append(leaf)
        return violators, len(total)
    def check_beamed_long_notes(self, argument=None):
        r'''Checks beamed long notes.

        ..  container:: example

            >>> staff = abjad.Staff("c'8 d' e' f'4.")
            >>> abjad.attach(abjad.Beam(), staff[:])

            >>> manager = abjad.WellformednessManager()
            >>> violators, total = manager.check_beamed_long_notes(staff)
            >>> violators
            [Note("f'4.")]

        Returns pair.

        First item in pair is list of beamed long notes.

        Second item in pair is count of all long notes in `argument`.
        '''
        import abjad
        violators, total = [], set()
        smart_beams = (
            abjad.DuratedComplexBeam,
            abjad.MultipartBeam,
        )
        for leaf in abjad.iterate(argument).leaves():
            if leaf.written_duration < abjad.Duration(1, 4):
                continue
            total.add(leaf)
            beams = abjad.inspect(leaf).get_spanners(abjad.Beam)
            for beam in beams:
                if isinstance(beam, smart_beams):
                    continue
                violators.append(leaf)
        return violators, len(total)
Example #20
0
 def _respell_tuplets(self, music):
     multiplier = abjad.Multiplier(3, 2)
     for tuplet in abjad.iterate(music).by_class(abjad.Tuplet):
         if tuplet.multiplier == multiplier:
             for note in tuplet:
                 new_written_duration = multiplier * note.written_duration
                 note.written_duration = new_written_duration
Example #21
0
 def _attach_leaf_index_markup(self, music):
     if not self.index_logical_ties:
         return
     logical_ties = abjad.iterate(music).by_logical_tie()
     for i, logical_tie in enumerate(logical_ties):
         markup = abjad.Markup(i)
         abjad.attach(markup, logical_tie.head)
Example #22
0
 def attach_glissandi(nucleus_voice):
     selections = [[]]
     leaves = abjad.iterate(nucleus_voice).leaves()
     for leaf_index, leaf in enumerate(leaves):
         if 641 <= leaf_index:
             leaf_index += 2
         string = letter_maker.nuclei[leaf_index]
         if string == 0:
             glissando = False
         else:
             result = letter_maker.get_body_pitch_shape_glissando(string)
             pitch, shape, glissando = result
         if glissando:
             assert isinstance(leaf, abjad.Note), repr(leaf)
             selections[-1].append(leaf)
         elif not selections[-1] == []:
             selections.append([])
     if selections[-1] == []:
         selections.pop()
     selections = [abjad.select(_) for _ in selections]
     for selection in selections:
         next_leaf = abjad.inspect(selection[-1]).leaf(1)
         if next_leaf is not None:
             selection = selection + [next_leaf]
         abjad.glissando(selection, allow_repeats=True)
         triples = abjad.sequence(selection).nwise(n=3)
         for left_note, middle_note, right_note in triples:
             if not (left_note.written_pitch ==
                 middle_note.written_pitch ==
                 right_note.written_pitch):
                 continue
             abjad.override(middle_note).note_head.transparent = True
             grob_proxy = abjad.override(middle_note).glissando
             grob_proxy.bound_details__left__padding = -1.2
Example #23
0
 def _strip_ties_(self, divisions):
     import abjad
     if not self.strip_ties:
         return
     for division in divisions:
         for leaf in abjad.iterate(division).leaves():
             abjad.detach(abjad.Tie, leaf)
Example #24
0
File: part.py Project: Abjad/abjad
def add_string_music_to_score(score):
    """
    Adds string music to score.
    """
    # generate some pitch and rhythm information
    pitch_contour_reservoir = create_pitch_contour_reservoir()
    shadowed_contour_reservoir = shadow_pitch_contour_reservoir(
        pitch_contour_reservoir
    )
    durated_reservoir = durate_pitch_contour_reservoir(
        shadowed_contour_reservoir
    )
    # add six dotted-whole notes and the durated contours to each string voice
    for name, descents in durated_reservoir.items():
        instrument_voice = score["%s Voice" % name]
        instrument_voice.extend("R1. R1. R1. R1. R1. R1.")
        for descent in descents:
            instrument_voice.extend(descent)
    # apply instrument-specific edits
    edit_first_violin_voice(score, durated_reservoir)
    edit_second_violin_voice(score, durated_reservoir)
    edit_viola_voice(score, durated_reservoir)
    edit_cello_voice(score, durated_reservoir)
    edit_bass_voice(score, durated_reservoir)
    # chop all string parts into 6/4 measures
    strings_staff_group = score["Strings Staff Group"]
    with abjad.ForbidUpdate(score):
        for voice in abjad.iterate(strings_staff_group).components(
            abjad.Voice
        ):
            shards = abjad.mutate(voice[:]).split([(6, 4)], cyclic=True)
            for shard in shards:
                container = abjad.Container()
                abjad.mutate(shard).wrap(container)
Example #25
0
File: part.py Project: gsy/gmajor
def apply_expressive_marks(score):
    """
    Applies expressive marks to score.
    """
    voice = score['First Violin Voice']
    markup = abjad.Markup(
        r'\left-column { div. \line { con sord. } }', direction=abjad.Up)
    abjad.attach(markup, voice[6][1])
    markup = abjad.Markup('sim.', direction=abjad.Up)
    abjad.attach(markup, voice[8][0])
    markup = abjad.Markup('uniti', direction=abjad.Up)
    abjad.attach(markup, voice[58][3])
    markup = abjad.Markup('div.', direction=abjad.Up)
    abjad.attach(markup, voice[59][0])
    markup = abjad.Markup('uniti', direction=abjad.Up)
    abjad.attach(markup, voice[63][3])

    voice = score['Second Violin Voice']
    markup = abjad.Markup('div.', direction=abjad.Up)
    abjad.attach(markup, voice[7][0])
    markup = abjad.Markup('uniti', direction=abjad.Up)
    abjad.attach(markup, voice[66][1])
    markup = abjad.Markup('div.', direction=abjad.Up)
    abjad.attach(markup, voice[67][0])
    markup = abjad.Markup('uniti', direction=abjad.Up)
    abjad.attach(markup, voice[74][0])

    voice = score['Viola Voice']
    markup = abjad.Markup('sole', direction=abjad.Up)
    abjad.attach(markup, voice[8][0])

    voice = score['Cello Voice']
    markup = abjad.Markup('div.', direction=abjad.Up)
    abjad.attach(markup, voice[10][0])
    markup = abjad.Markup('uniti', direction=abjad.Up)
    abjad.attach(markup, voice[74][0])
    markup = abjad.Markup('uniti', direction=abjad.Up)
    abjad.attach(markup, voice[84][1])
    markup = abjad.Markup(r'\italic { espr. }', direction=abjad.Down)
    abjad.attach(markup, voice[86][0])
    markup = abjad.Markup(r'\italic { molto espr. }', direction=abjad.Down)
    abjad.attach(markup, voice[88][1])

    voice = score['Bass Voice']
    markup = abjad.Markup('div.', direction=abjad.Up)
    abjad.attach(markup, voice[14][0])
    markup = abjad.Markup(r'\italic { espr. }', direction=abjad.Down)
    abjad.attach(markup, voice[86][0])
    abjad.mutate(voice[88][:]).split(
        [abjad.Duration(1, 1), abjad.Duration(1, 2)]
        )
    markup = abjad.Markup(r'\italic { molto espr. }', direction=abjad.Down)
    abjad.attach(markup, voice[88][1])
    markup = abjad.Markup('uniti', direction=abjad.Up)
    abjad.attach(markup, voice[99][1])

    strings_staff_group = score['Strings Staff Group']
    for voice in abjad.iterate(strings_staff_group).components(abjad.Voice):
        markup = abjad.Markup(r'\italic { (non dim.) }', direction=abjad.Down)
        abjad.attach(markup, voice[102][0])
def add_new_spacing_section(meter_voice, start_measure_number, new_moment,
    revert_measure_number = None):

    normal_spacing_duration = abjad.schemetools.SchemeMoment(1, 96)
    if revert_measure_number is None:
        revert_measure_number = start_measure_number + 1

    #measure = measuretools.get_one_indexed_measure_number_in_expr(
    #    meter_voice, start_measure_number)
    measures = list(abjad.iterate(meter_voice).by_class(abjad.Measure))

    start_measure_index = start_measure_number - 1
    measure = measures[start_measure_index]
    command = abjad.LilyPondCommand('newSpacingSection', 'before')
    abjad.attach(command, measure)
    moment = abjad.schemetools.SchemeMoment(new_moment)
    #measure.set.score.proportional_notation_duration = moment
    abjad.set_(measure).score.proportional_notation_duration = moment

    #measure = measuretools.get_one_indexed_measure_number_in_expr(
    #    meter_voice, revert_measure_number)
    revert_measure_index = revert_measure_number - 1
    measure = measures[revert_measure_index]

    command = abjad.LilyPondCommand('newSpacingSection', 'before')
    abjad.attach(command, measure)
    abjad.set_(measure).score.proportional_notation_duration = \
        normal_spacing_duration
Example #27
0
def cross_staves_down(
    voice, 
    start, 
    stop, 
    bp, 
    target,
    includes=[], 
    excludes=[],
    topBeamPositions=None, 
    bottomBeamPositions=None,
    ):
    r'''target is a reference to an actual Staff instance.

    TODO: run octavate at some time other than cross-determination time.
    '''
    leaves = abjad.iterate(voice).by_leaf()
    leaves = list(leaves)
    for j, l in enumerate(leaves[start : stop + 1]):
        i = start + j
        if isinstance(l, Note):
            #if (bp <= l.safePitchNumber or i in includes) and i not in excludes:
            if ((bp <= lidercfeny.etc.transforms.get_lowest_pitch(l) or
                i in includes) and i not in excludes):
                l.staff = target
            else:
                octavate(l, base = (-4, 30))
def append_articulations(voice, articulations, *args, **kwargs):
    r'''Iterates leaves and append articulations.
    '''
    leaves = abjad.iterate(voice).by_leaf()
    leaves = list(leaves)
    if len(args) == 0:
        start = 0
        stop = len(leaves)
    elif len(args) == 1:
        start = stop = args
    elif len(args) == 2:
        start, stop = args
    else:
        raise ValueError
    leafSlice = leaves[start : stop + 1]
    if kwargs.has_key('exclude'):
        exclude = kwargs['exclude']
    else:
        exclude = True
    for l in leaves:
        if isinstance(l, (Note, Chord)) or not exclude:
            if isinstance(articulations, str):
                l.articulations.append(articulations)
            elif isinstance(articulations, list):
                for articulation in articulations:
                    l.articulations.extend(articulation)
            else:
                raise ValueError
Example #29
0
def set_pitches_by_pitch_cycle(voice, start, stop, pcyc):
    leaves = abjad.iterate(voice).by_leaf()
    leaves = list(leaves)
    for j, l in enumerate(leaves[start : stop + 1]):
        i = j + start
        p = pcyc[j % len(pcyc)]
        l.pitch = p
Example #30
0
    def _replace(self, old_leaf, new_leaf):
        grace_containers = inspect_(old_leaf).get_grace_containers('after')
        if grace_containers:
            old_grace_container = grace_containers[0]
            grace_notes = list(iterate(old_grace_container).by_leaf())
            detach(scoretools.GraceContainer, old_leaf)

        indicator_expressions = inspect_(old_leaf).get_indicators(unwrap=False)
        #for indicator_expression in indicator_expressions:
        #    detach(indicator, old_leaf)

        timespan = old_leaf._timespan
        start_offset = old_leaf._start_offset
        stop_offset = old_leaf._stop_offset
        logical_measure_number = old_leaf._logical_measure_number
        mutate(old_leaf).replace(new_leaf)
        new_leaf._timespan = timespan
        new_leaf._start_offset = start_offset
        new_leaf._stop_offset = stop_offset
        new_leaf._logical_measure_number = logical_measure_number

        if grace_containers:
            new_grace_container = scoretools.GraceContainer(
                grace_notes,
                kind='after',
                )
            attach(new_grace_container, new_leaf)

        for indicator_expression in indicator_expressions:
            attach(indicator_expression, new_leaf)
Example #31
0
    def add_final_bar_line(
        self,
        abbreviation='|.',
        to_each_voice=False,
    ):
        r"""
        Add final bar line to end of score.


            >>> staff = abjad.Staff("c'4 d'4 e'4 f'4")
            >>> score = abjad.Score([staff])
            >>> abjad.show(score) # doctest: +SKIP

        ..  docs::

            >>> abjad.f(score)
            \new Score
            <<
                \new Staff
                {
                    c'4
                    d'4
                    e'4
                    f'4
                }
            >>


        >>> bar_line = score.add_final_bar_line()
        >>> abjad.show(score) # doctest: +SKIP

        ..  docs::

            >>> abjad.f(score)
            \new Score
            <<
                \new Staff
                {
                    c'4
                    d'4
                    e'4
                    f'4
                    \bar "|." %! SCORE_1
                }
            >>

        Set ``to_each_voice`` to true to make part extraction easier.

        Returns bar line.
        """
        import abjad
        bar_line = abjad.BarLine(abbreviation)
        if not to_each_voice:
            last_leaf = abjad.inspect(self).leaf(-1)
            abjad.attach(bar_line, last_leaf, tag='SCORE_1')
        else:
            for voice in abjad.iterate(self).components(abjad.Voice):
                last_leaf = abjad.inspect(voice).leaf(-1)
                abjad.attach(bar_line, last_leaf, tag='SCORE_1')
        return bar_line
Example #32
0
 def rosatize(self):
     # transposing up an octave and add dynamic for Rosa Guitar Trio
     for staff in self.skeleton:
         first_leaf = abjad.inspect(staff).leaf(0)
         abjad.attach(abjad.Dynamic('pp'), first_leaf)
         for note in abjad.iterate(staff).components(prototype=abjad.Note):
             note.written_pitch += 12
    def _replace(self, old_leaf, new_leaf):
        after_grace = abjad.inspect(old_leaf).get_after_grace_container()
        if after_grace is not None:
            old_after_grace = after_grace
            grace_notes = list(iterate(old_after_grace).by_leaf())
            detach(scoretools.GraceContainer, old_leaf)

        indicator_expressions = abjad.inspect(old_leaf).get_indicators(unwrap=False)
        #for indicator_expression in indicator_expressions:
        #    detach(indicator, old_leaf)

        timespan = old_leaf._timespan
        start_offset = old_leaf._start_offset
        stop_offset = old_leaf._stop_offset
        logical_measure_number = old_leaf._logical_measure_number
        mutate(old_leaf).replace(new_leaf)
        new_leaf._timespan = timespan
        new_leaf._start_offset = start_offset
        new_leaf._stop_offset = stop_offset
        new_leaf._logical_measure_number = logical_measure_number

        if after_grace is not None:
            new_after_grace = scoretools.AfterGraceContainer(grace_notes)
            attach(new_after_grace, new_leaf)

        for indicator_expression in indicator_expressions:
            attach(indicator_expression, new_leaf)
Example #34
0
def applyCoverSpanner(voice, *args):
    leaves = abjad.iterate(voice).by_leaf()
    leaves = list(leaves)
    if len(args) == 1:
        i = args[0]
        leaves[i].formatter.right.append(
            r'^ \markup { \italic \fontsize #2 "coperta" }')
    elif len(args) == 2:
        start, stop = args
        leaves[start].formatter.before.extend([
            r"\once \override TextSpanner #'bound-details #'left-broken " +
                r"#'X = #8",
            r"\once \override TextSpanner #'dash-fraction = #0.25",
            r"\once \override TextSpanner #'dash-period = #1",
            r"\once \override TextSpanner #'bound-details #'left " + \
                r"""#'text = \markup { \italic \fontsize #2 "coperta " }""",
            r"\once \override TextSpanner #'bound-details #'left " + \
                r"#'stencil-align-dir-y = #CENTER",
            r"\once \override TextSpanner #'bound-details #'right-broken " +
                r"#'text = ##f",
            r"\once \override TextSpanner #'bound-details #'right " +
                r"#'text = #(markup #:draw-line '(0 . -1))",
            r"\once \override TextSpanner #'staff-padding = #6",
            r"\once \override TextSpanner #'extra-offset = #'(0 . -2.5)"
            ])
        leaves[start].formatter.right.append(r'\startTextSpan')
        leaves[stop].formatter.right.append(r'\stopTextSpan')
    else:
        raise ValueError('can not apply cover spanner.')
Example #35
0
File: part.py Project: Abjad/abjad
def apply_bowing_marks(score):
    """
    Applies bowing marks to score.
    """
    # apply alternating upbow and downbow for first two sounding bars
    # of the first violin
    for measure in score["First Violin Voice"][6:8]:
        for i, chord in enumerate(
            abjad.iterate(measure).components(abjad.Chord)
        ):
            if i % 2 == 0:
                articulation = abjad.Articulation("downbow")
                abjad.attach(articulation, chord)
            else:
                articulation = abjad.Articulation("upbow")
                abjad.attach(articulation, chord)

    # create and apply rebowing markup
    rebow_markup = abjad.Markup.concat(
        [
            abjad.Markup.musicglyph("scripts.downbow"),
            abjad.Markup.hspace(1),
            abjad.Markup.musicglyph("scripts.upbow"),
        ]
    )
    markup = copy.copy(rebow_markup)
    abjad.attach(markup, score["First Violin Voice"][64][0])
    markup = copy.copy(rebow_markup)
    abjad.attach(markup, score["Second Violin Voice"][75][0])
    markup = copy.copy(rebow_markup)
    abjad.attach(markup, score["Viola Voice"][86][0])
def test_scoretools_Component__measure_number_02():

    
    staff = abjad.Staff()
    staff.append(abjad.Measure((2, 4), "c'4 d'4"))
    staff.append(abjad.Measure((2, 4), "e'4 f'4"))
    staff.append(abjad.Measure((3, 4), "g'4 a'4 b'4"))
    staff.append(abjad.Measure((1, 4), "c''4"))
    staff._update_measure_numbers()

    assert staff._measure_number == 1

    assert staff[0]._measure_number == 1
    assert staff[1]._measure_number == 2
    assert staff[2]._measure_number == 3
    assert staff[3]._measure_number == 4

    leaves = abjad.iterate(staff).leaves()
    leaves = list(leaves)
    assert leaves[0]._measure_number == 1
    assert leaves[1]._measure_number == 1
    assert leaves[2]._measure_number == 2
    assert leaves[3]._measure_number == 2
    assert leaves[4]._measure_number == 3
    assert leaves[5]._measure_number == 3
    assert leaves[6]._measure_number == 3
    assert leaves[7]._measure_number == 4
Example #37
0
    def __call__(self, expr):
        r'''Calls specifier on `expr`.

        Returns none.
        '''
        if self.dynamic is None:
            return
        #print(expr)
        selector = self._get_selector()
        #print(selector)
        selections = selector(expr)
        #print(selections)
        for selection in selections:
            if isinstance(self.dynamic, abjad.spannertools.Hairpin):
                hairpin = abjad.new(self.dynamic)
                leaves = list(abjad.iterate(selection).by_leaf())
                if hairpin._attachment_test_all(leaves):
                    abjad.attach(hairpin, leaves)
            elif isinstance(self.dynamic, (str, abjad.indicatortools.Dynamic)):
                dynamic = abjad.indicatortools.Dynamic(self.dynamic)
                abjad.attach(dynamic, selection[0])
            else:
                message = 'invalid dynamic: {!r}.'
                message = message.format(self.dynamic)
                raise Exception(message)
Example #38
0
    def transpose_from_written_pitch(argument):
        r"""
        Transposes notes and chords in `argument` from sounding pitch
        to written pitch.

        ..  container:: example

            >>> staff = abjad.Staff("<c' e' g'>4 d'4 r4 e'4")
            >>> clarinet = abjad.ClarinetInBFlat()
            >>> abjad.attach(clarinet, staff[0])
            >>> abjad.show(staff) # doctest: +SKIP

            ..  docs::

                >>> abjad.f(staff)
                \new Staff
                {
                    \set Staff.instrumentName = \markup { "Clarinet in B-flat" }
                    \set Staff.shortInstrumentName = \markup { "Cl. in B-flat" }
                    <c' e' g'>4
                    d'4
                    r4
                    e'4
                }

            >>> abjad.Instrument.transpose_from_written_pitch(staff)
            >>> abjad.show(staff) # doctest: +SKIP

            ..  docs::

                >>> abjad.f(staff)
                \new Staff
                {
                    \set Staff.instrumentName = \markup { "Clarinet in B-flat" }
                    \set Staff.shortInstrumentName = \markup { "Cl. in B-flat" }
                    <bf d' f'>4
                    c'4
                    r4
                    d'4
                }

        Returns none.
        """
        import abjad
        for leaf in abjad.iterate(argument).leaves(pitched=True):
            instrument = abjad.inspect(leaf).get_effective(abjad.Instrument)
            if not instrument:
                continue
            sounding_pitch = instrument.middle_c_sounding_pitch
            interval = abjad.NamedPitch('C4') - sounding_pitch
            if isinstance(leaf, abjad.Note):
                written_pitch = leaf.written_pitch
                written_pitch = interval.transpose(written_pitch)
                leaf.written_pitch = written_pitch
            elif isinstance(leaf, abjad.Chord):
                pitches = [
                    interval.transpose(pitch)
                    for pitch in leaf.written_pitches
                    ]
                leaf.written_pitches = pitches
Example #39
0
 def _populate_time_signature_context(self):
     time_signature_context = self._score['Time Signature Context']
     music_voice = self._score['Music Voice']
     measure_durations = []
     current_duration = abjad.Duration(0)
     ideal_measure_duration = abjad.Duration(4, 4)
     for component in music_voice:
         component_duration = abjad.inspect_(component).get_duration()
         candidate_duration = current_duration + component_duration
         if ideal_measure_duration < candidate_duration:
             if 0 < current_duration:
                 measure_durations.append(current_duration)
             current_duration = component_duration
         else:
             current_duration = candidate_duration
     measure_durations.append(current_duration)
     measures = abjad.scoretools.make_spacer_skip_measures(
         measure_durations)
     time_signature_context.extend(measures)
     for measure in abjad.iterate(time_signature_context).by_class(abjad.Measure):
         time_signature = abjad.inspect_(measure).get_indicator(abjad.TimeSignature)
         if time_signature.denominator < 4:
             fraction = abjad.mathtools.NonreducedFraction(
                 time_signature.pair)
             fraction = fraction.with_multiple_of_denominator(4)
             abjad.detach(time_signature, measure)
             new_time_signature = abjad.TimeSignature(fraction)
             abjad.attach(new_time_signature, measure)
Example #40
0
 def _tie_consecutive_notes_(self, divisions):
     import abjad
     if not self.tie_consecutive_notes:
         return
     leaves = list(abjad.iterate(divisions).leaves())
     for leaf in leaves:
         abjad.detach(abjad.Tie, leaf)
     pairs = itertools.groupby(leaves, lambda _: _.__class__)
     def _get_pitches(component):
         if isinstance(component, abjad.Note):
             return component.written_pitch
         elif isinstance(component, abjad.Chord):
             return component.written_pitches
         else:
             raise TypeError(component)
     for class_, group in pairs:
         group = list(group)
         if not isinstance(group[0], (abjad.Note, abjad.Chord)):
             continue
         subpairs = itertools.groupby(group, lambda _: _get_pitches(_))
         for pitches, subgroup in subpairs:
             subgroup = list(subgroup)
             if len(subgroup) == 1:
                 continue
             tie = abjad.Tie()
             assert tie._attachment_test_all(subgroup) is True
             abjad.attach(tie, abjad.select(subgroup))
Example #41
0
    def check_empty_containers(self, argument=None):
        r"""
        Checks empty containers.

        ..  container:: example

            >>> staff = abjad.Staff("c'4 d' e' f'")
            >>> staff.append(abjad.Container())

            >>> abjad.f(staff)
            \new Staff
            {
                c'4
                d'4
                e'4
                f'4
                {
                }
            }

            >>> manager = abjad.WellformednessManager()
            >>> violators, total = manager.check_empty_containers(staff)
            >>> violators
            [Container()]

        Returns list of empty containers and count of all containers in
        ``argument``.
        """
        import abjad
        violators, containers = [], set()
        for container in abjad.iterate(argument).components(abjad.Container):
            containers.add(container)
            if len(container) == 0:
                violators.append(container)
        return violators, len(containers)
Example #42
0
 def _compound_scope_to_logical_ties(
     self, 
     compound_scope,
     include_rests=False,
     ):
     import huitzil
     timespan_map, timespans = [], []
     for scope in compound_scope.simple_scopes:
         start_stage, stop_stage = scope.stages
         offsets = self._get_offsets(start_stage, stop_stage)
         timespan = abjad.timespantools.Timespan(*offsets)
         timespan_map.append((scope.voice_name, timespan))
         timespans.append(timespan)
     compound_scope._timespan_map = timespan_map
     voice_names = [_[0] for _ in timespan_map]
     compound_scope._voice_names = tuple(voice_names)
     logical_ties = []
     if include_rests:
         prototype = (abjad.Note, abjad.Chord, abjad.Rest)
     else:
         prototype = (abjad.Note, abjad.Chord)
     for note in abjad.iterate(self._score).by_timeline(prototype):
         if note in compound_scope:
             logical_tie = abjad.inspect_(note).get_logical_tie()
             if logical_tie.head is note:
                 logical_ties.append(logical_tie)
     start_offset = min(_.start_offset for _ in timespans)
     stop_offset = max(_.stop_offset for _ in timespans)
     timespan = abjad.timespantools.Timespan(start_offset, stop_offset)
     return logical_ties, timespan
    def __call__(self, argument):
        r'''Calls naive attack-point optimizer.

        Returns none.
        '''
        import abjad
        for logical_tie in abjad.iterate(argument).logical_ties(
                grace_notes=False,
                reverse=True,
        ):
            sub_logical_ties = []
            current_sub_logical_tie = []
            for leaf in logical_tie:
                tempos = leaf._get_indicators(abjad.MetronomeMark)
                if tempos:
                    if current_sub_logical_tie:
                        current_sub_logical_tie = abjad.LogicalTie(
                            current_sub_logical_tie)
                        sub_logical_ties.append(current_sub_logical_tie)
                    current_sub_logical_tie = []
                current_sub_logical_tie.append(leaf)
            if current_sub_logical_tie:
                current_sub_logical_tie = abjad.LogicalTie(
                    current_sub_logical_tie)
                sub_logical_ties.append(current_sub_logical_tie)
            for sub_logical_tie in sub_logical_ties:
                sub_logical_tie._fuse_leaves_by_immediate_parent()
Example #44
0
 def add_passaggi(self):
     self.last_passaggi_ornaments = [self.last_ornament_chosen] * 3
     self.last_passaggi_voice = None  # to implement: ornament a different voice each time
     moments = list(abjad.iterate(self.score).vertical_moments())
     for moment_pair in zip(moments, moments[1:]):
         first_starts = moment_pair[0].start_notes
         next_starts = moment_pair[1].start_notes
         if len(self.score) == len(first_starts) == len(next_starts):
             if self.moment_contains_only_base_values(moment_pair[0]):
                 adjacencies = [
                     Adjacency(moment_pair[0], moment_pair[1], i)
                     for i in range(3)
                 ]
                 if False in [
                         'P1' == a.melodic_interval.name
                         for a in adjacencies
                 ]:
                     adjacencies = [
                         a for a in adjacencies
                         if a.melodic_interval.name != 'P1'
                     ]
                     adjacencies = [a for a in adjacencies \
                     if not self.succeeds_imitation(a.from_note)]
                     adjacency = self.choose_adjacency(adjacencies)
                     if 2 <= len(adjacencies):
                         adjacency = self.ensure_novel_staff_choice(
                             adjacencies, adjacency)
                     self.last_passaggi_voice = adjacency.staff_index
                     self.add_passaggio_to_adjacency(adjacency)
     self.last_ornament_chosen = self.last_passaggi_ornaments[0]
Example #45
0
 def detach_grace_containers(containers, indices):
     #for i, leaf in enumerate(abjad.iterate(containers).leaves()):
     leaves = abjad.iterate(containers).leaves(grace_notes=False)
     for i, leaf in enumerate(leaves):
         if i not in indices:
             continue
         abjad.detach(abjad.GraceContainer, leaf)
Example #46
0
 def _get_previous_measure(self):
     import abjad
     if isinstance(self, abjad.Leaf):
         for parent in abjad.inspect(self).get_parentage(
                 include_self=False):
             if isinstance(parent, abjad.Measure):
                 return parent
         raise MissingMeasureError
     elif isinstance(self, abjad.Measure):
         return self._get_in_my_logical_voice(-1, prototype=abjad.Measure)
     elif isinstance(self, abjad.Container):
         contents = self._get_descendants_stopping_with()
         contents = [x for x in contents if isinstance(x, abjad.Measure)]
         if contents:
             return contents[0]
         raise MissingMeasureError
     elif isinstance(self, (list, tuple)):
         measure_generator = abjad.iterate(self).components(
             abjad.Measure,
             reverse=True,
         )
         try:
             measure = next(measure_generator)
             return measure
         except StopIteration:
             raise MissingMeasureError
     else:
         message = 'unknown component: {!r}.'
         raise TypeError(message.format(self))
 def __call__(self, music, name=None):
     import consort
     leaves = list(iterate(music).by_leaf())
     weights = []
     weighted_pitches = []
     for leaf in leaves:
         weight = float(inspect(leaf).get_duration())
         if isinstance(leaf, abjad.Note):
             pitch = float(leaf.written_pitch)
             weighted_pitch = pitch * weight
             weights.append(weight)
             weighted_pitches.append(weighted_pitch)
         elif isinstance(leaf, abjad.Chord):
             for pitch in leaf.written_pitches:
                 pitch = float(pitch)
                 weighted_pitch = pitch * weight
                 weighted_pitches.append(weighted_pitch)
                 weights.append(weight)
     sum_of_weights = sum(weights)
     sum_of_weighted_pitches = sum(weighted_pitches)
     weighted_average = sum_of_weighted_pitches / sum_of_weights
     if weighted_average < 0:
         clef_spanner = consort.ClefSpanner('bass')
     else:
         clef_spanner = consort.ClefSpanner('treble')
     attach(clef_spanner, music, name=name)
Example #48
0
def apply_bowing_marks(score):
    """
    Applies bowing marks to score.
    """
    # apply alternating upbow and downbow for first two sounding bars
    # of the first violin
    for measure in score['First Violin Voice'][6:8]:
        for i, chord in enumerate(
                abjad.iterate(measure).components(abjad.Chord)):
            if i % 2 == 0:
                articulation = abjad.Articulation('downbow')
                abjad.attach(articulation, chord)
            else:
                articulation = abjad.Articulation('upbow')
                abjad.attach(articulation, chord)

    # create and apply rebowing markup
    rebow_markup = abjad.Markup.concat([
        abjad.Markup.musicglyph('scripts.downbow'),
        abjad.Markup.hspace(1),
        abjad.Markup.musicglyph('scripts.upbow'),
    ])
    markup = copy.copy(rebow_markup)
    abjad.attach(markup, score['First Violin Voice'][64][0])
    markup = copy.copy(rebow_markup)
    abjad.attach(markup, score['Second Violin Voice'][75][0])
    markup = copy.copy(rebow_markup)
    abjad.attach(markup, score['Viola Voice'][86][0])
Example #49
0
 def __call__(self, music, name=None):
     leaves = list(iterate(music).by_leaf())
     weights = []
     weighted_pitches = []
     for leaf in leaves:
         weight = float(inspect_(leaf).get_duration())
         if isinstance(leaf, scoretools.Note):
             pitch = float(leaf.written_pitch)
             weighted_pitch = pitch * weight
             weights.append(weight)
             weighted_pitches.append(weighted_pitch)
         elif isinstance(leaf, scoretools.Chord):
             for pitch in leaf.written_pitches:
                 pitch = float(pitch)
                 weighted_pitch = pitch * weight
                 weighted_pitches.append(weighted_pitch)
                 weights.append(weight)
     sum_of_weights = sum(weights)
     sum_of_weighted_pitches = sum(weighted_pitches)
     weighted_average = sum_of_weighted_pitches / sum_of_weights
     #print(music, weighted_average)
     clef = inspect_(leaves[0]).get_effective(indicatortools.Clef)
     octavation_spanner = None
     if clef == indicatortools.Clef('treble'):
         if int(pitchtools.NamedPitch('C6')) <= int(weighted_average):
             octavation_spanner = spannertools.OctavationSpanner()
     elif clef == indicatortools.Clef('bass'):
         pass
     if octavation_spanner is not None:
         attach(octavation_spanner, music)
Example #50
0
def add_string_music_to_score(score):
    """
    Adds string music to score.
    """
    # generate some pitch and rhythm information
    pitch_contour_reservoir = create_pitch_contour_reservoir()
    shadowed_contour_reservoir = shadow_pitch_contour_reservoir(
        pitch_contour_reservoir)
    durated_reservoir = durate_pitch_contour_reservoir(
        shadowed_contour_reservoir)
    # add six dotted-whole notes and the durated contours to each string voice
    for name, descents in durated_reservoir.items():
        instrument_voice = score['%s Voice' % name]
        instrument_voice.extend("R1. R1. R1. R1. R1. R1.")
        for descent in descents:
            instrument_voice.extend(descent)
    # apply instrument-specific edits
    edit_first_violin_voice(score, durated_reservoir)
    edit_second_violin_voice(score, durated_reservoir)
    edit_viola_voice(score, durated_reservoir)
    edit_cello_voice(score, durated_reservoir)
    edit_bass_voice(score, durated_reservoir)
    # chop all string parts into 6/4 measures
    strings_staff_group = score['Strings Staff Group']
    with abjad.ForbidUpdate(score):
        for voice in abjad.iterate(strings_staff_group).components(
                abjad.Voice):
            shards = abjad.mutate(voice[:]).split([(6, 4)], cyclic=True)
            for shard in shards:
                container = abjad.Container()
                abjad.mutate(shard).wrap(container)
Example #51
0
 def _apply_denominator(self, selections, divisions):
     import abjad
     if not self.denominator:
         return
     tuplets = list(abjad.iterate(selections).components(abjad.Tuplet))
     if divisions is None:
         divisions = len(tuplets) * [None]
     assert len(selections) == len(divisions)
     assert len(tuplets) == len(divisions)
     denominator = self.denominator
     if isinstance(denominator, tuple):
         denominator = abjad.Duration(denominator)
     for tuplet, division in zip(tuplets, divisions):
         if denominator == 'divisions':
             tuplet.denominator = division.numerator
         elif isinstance(denominator, abjad.Duration):
             unit_duration = denominator
             assert unit_duration.numerator == 1
             duration = abjad.inspect(tuplet).get_duration()
             denominator_ = unit_duration.denominator
             nonreduced_fraction = duration.with_denominator(denominator_)
             tuplet.denominator = nonreduced_fraction.numerator
         elif abjad.mathtools.is_positive_integer(denominator):
             tuplet.denominator = denominator
         else:
             message = f'invalid preferred denominator: {denominator!r}.'
             raise Exception(message)
Example #52
0
    def __call__(self, container, imbrication_token):
        r'''Calls imbrication specifier on `container`.

        Returns new container.
        '''
        container = copy.deepcopy(container)
        imbrication_token = abjad.sequence(imbrication_token)
        imbrication_token = imbrication_token.flatten()
        cursor = baca.tools.Cursor(
            imbrication_token,
            singletons=True,
            suppress_exception=True,
            )
        pitch_number = cursor.next()
        logical_ties = abjad.iterate(container).by_logical_tie(pitched=True)
        for logical_tie in logical_ties:
            if logical_tie.head.written_pitch.pitch_number == pitch_number:
                pitch_number = cursor.next()
                if self.truncate_ties:
                    for note in logical_tie[1:]:
                        duration = note.written_duration
                        skip = abjad.Skip(duration)
                        abjad.mutate(note).replace([skip])
            else:
                for note in logical_tie:
                    duration = note.written_duration
                    skip = abjad.Skip(duration)
                    abjad.mutate(note).replace([skip])
        self._apply_specifiers(container)
        return container
def test_scoretools_Mutation_copy_07():

    voice = abjad.Voice("abj: | 2/8 c'8 d'8 || 2/8 e'8 f'8 |"
                        "| 2/8 g'8 a'8 || 2/8 b'8 c''8 |")
    leaves = abjad.select(voice).leaves()
    beam = abjad.Beam()
    abjad.attach(beam, leaves)
    slur = abjad.Slur()
    abjad.attach(slur, leaves)

    assert format(voice) == abjad.String.normalize(r'''
        \new Voice
        {
            {   % measure
                \time 2/8
                c'8
                [
                (
                d'8
            }   % measure
            {   % measure
                e'8
                f'8
            }   % measure
            {   % measure
                g'8
                a'8
            }   % measure
            {   % measure
                b'8
                c''8
                ]
                )
            }   % measure
        }
        ''')

    result = abjad.mutate(voice[-2:]).copy()
    new_voice = abjad.Voice(result)
    for component in abjad.iterate(new_voice).components():
        abjad.detach(abjad.Spanner, component)

    assert format(new_voice) == abjad.String.normalize(r'''
        \new Voice
        {
            {   % measure
                \time 2/8
                g'8
                a'8
            }   % measure
            {   % measure
                b'8
                c''8
            }   % measure
        }
        ''')

    assert abjad.inspect(voice).is_well_formed()
    assert abjad.inspect(new_voice).is_well_formed()
Example #54
0
    def transpose_from_sounding_pitch(argument):
        r'''Transpose notes and chords in `argument` from sounding pitch
        to written pitch:

        ..  container:: example

            >>> staff = abjad.Staff("<c' e' g'>4 d'4 r4 e'4")
            >>> clarinet = abjad.ClarinetInBFlat()
            >>> abjad.attach(clarinet, staff[0])
            >>> abjad.show(staff) # doctest: +SKIP

            ..  docs::

                >>> abjad.f(staff)
                \new Staff
                {
                    \set Staff.instrumentName = \markup { "Clarinet in B-flat" }
                    \set Staff.shortInstrumentName = \markup { "Cl. in B-flat" }
                    <c' e' g'>4
                    d'4
                    r4
                    e'4
                }

            >>> abjad.Instrument.transpose_from_sounding_pitch(staff)
            >>> abjad.show(staff) # doctest: +SKIP

            ..  docs::

                >>> abjad.f(staff)
                \new Staff
                {
                    \set Staff.instrumentName = \markup { "Clarinet in B-flat" }
                    \set Staff.shortInstrumentName = \markup { "Cl. in B-flat" }
                    <d' fs' a'>4
                    e'4
                    r4
                    fs'4
                }

        Returns none.
        '''
        import abjad
        for leaf in abjad.iterate(argument).leaves(pitched=True):
            instrument = abjad.inspect(leaf).get_effective(abjad.Instrument)
            if not instrument:
                continue
            sounding_pitch = instrument.middle_c_sounding_pitch
            interval = abjad.NamedPitch('C4') - sounding_pitch
            interval *= -1
            if isinstance(leaf, abjad.Note):
                pitch = leaf.written_pitch
                pitch = interval.transpose(pitch)
                leaf.written_pitch = pitch
            elif isinstance(leaf, abjad.Chord):
                pitches = [
                    interval.transpose(pitch) for pitch in leaf.written_pitches
                ]
                leaf.written_pitches = pitches
Example #55
0
 def fuse_moments(self):
     for staff in self.score:
         for pair in abjad.iterate(staff).leaf_pairs():
             if self.resolution == pair[0].written_duration == pair[1].written_duration \
             and pair[0].written_pitch == pair[1].written_pitch \
             and 0 == abjad.inspect(pair[0]).vertical_moment().offset % (2 * self.resolution) \
             and not self.contains_suspension(pair):
                 abjad.mutate(pair).fuse()
Example #56
0
def music_to_ratios(music):
    """Converts an Abjad selection to rhythmic ratios."""
    ratios = []
    for tie in abjad.iterate(music).by_logical_tie():
        duration = abjad.inspect(tie).get_duration()
        fraction = fractions.Fraction(duration)
        ratios.append(fraction)
    return ratios
Example #57
0
def apply_final_bar_lines(score):
    """
    Applies final bar lines to score.
    """
    for voice in abjad.iterate(score).components(abjad.Voice):
        bar_line = abjad.BarLine('|.')
        leaf = abjad.inspect(voice).leaf(-1)
        abjad.attach(bar_line, leaf)