def test_LilyPondParser__indicators__Markup_04():
command1 = abjad.MarkupCommand("bold", ["A", "B", "C"])
command2 = abjad.MarkupCommand("italic", "123")
markup = abjad.Markup((command1, command2))
parser = abjad.parser.LilyPondParser()
result = parser(abjad.lilypond(markup))
assert isinstance(result, abjad.Markup)
assert abjad.lilypond(result) == abjad.lilypond(markup)
def test_lilypondparsertools_LilyPondParser__indicators__Markup_04():
command1 = abjad.MarkupCommand('bold', ['A', 'B', 'C'])
command2 = abjad.MarkupCommand('italic', '123')
markup = abjad.Markup((command1, command2))
parser = abjad.lilypondparsertools.LilyPondParser()
result = parser(format(markup, 'lilypond'))
assert isinstance(result, abjad.Markup)
assert format(result, 'lilypond') == format(markup, 'lilypond')
def _markup(self) -> abjad.Markup:
return abjad.Markup(
[
abjad.MarkupCommand("vspace", -0.25),
abjad.MarkupCommand("fontsize", -4),
abjad.MarkupCommand("rounded-box",
['{}'.format(self.n_times)]),
abjad.MarkupCommand("hspace", -0.4),
abjad.MarkupCommand(
"path", 0.25,
abjad.LilyPondLiteral(self._ornamentation_path)),
],
direction="up",
)
def _to_score_markup(selection):
import abjad
staff, layout_block = Duration._make_markup_score_block(selection)
command = abjad.MarkupCommand("score", [staff, layout_block])
markup = abjad.Markup(command)
return markup
def _make_circle_outline_markup(size):
circle_outline = abjad.MarkupCommand(
'draw-circle',
size,
0.25,
False
)
return abjad.Markup(circle_outline)
def scpm(position: str) -> abjad.Markup:
return abjad.Markup(
[
abjad.MarkupCommand("fontsize", -2.4),
abjad.StringContactPoint(position).markup,
],
direction="up",
)
def _make_score_block(self,
make_layout_block: bool = False
) -> abjad.LilyPondFile:
score_block = super()._make_score_block(make_layout_block)
local_header = abjad.Block("header")
local_header.piece = abjad.Markup(
abjad.MarkupCommand(
"center-column",
[
abjad.MarkupCommand("vspace", 0),
abjad.MarkupCommand(
"rounded-box",
[
abjad.MarkupCommand("fontsize", 1.5),
abjad.MarkupCommand("smallCaps"),
"{}".format(self.title),
],
),
],
))
score_block.items.append(local_header)
return score_block
def __call__(self):
'''Calls woodwind fingering.
Returns markup command.
'''
import abjad
key_groups_as_scheme = []
cc_scheme_pair = abjad.SchemePair(('cc', self._center_column))
key_groups_as_scheme.append(cc_scheme_pair)
lh_scheme_pair = abjad.SchemePair(('lh', self._left_hand))
key_groups_as_scheme.append(lh_scheme_pair)
rh_scheme_pair = abjad.SchemePair(('rh', self._right_hand))
key_groups_as_scheme.append(rh_scheme_pair)
key_groups_as_scheme = abjad.Scheme(
key_groups_as_scheme,
quoting="'",
)
instrument_as_scheme = abjad.Scheme(self._name, quoting="'")
return abjad.MarkupCommand(
'woodwind-diagram',
instrument_as_scheme,
key_groups_as_scheme,
)
COMPOSITION_PATH = "aml/composition"
BUILD_PATH = "aml/build"
SCORE_PATH = "{}/score".format(BUILD_PATH)
PARTBOOKS_PATH = "{}/partbooks".format(SCORE_PATH)
INTRODUCTION_PATH = "{}/introduction".format(BUILD_PATH)
INTRODUCTION_PICTURES_PATH = "{}/pictures".format(INTRODUCTION_PATH)
COVER_PATH = "aml/cover"
STOCHASTIC_PITCH_ANALYSIS_PATH = "aml/stochastic_pitch_analysis"
PYO_SERVER = pyo.Server(sr=44100, audio="offline", nchnls=3)
PYO_SERVER.boot()
ADD_COMPROVISATION = False
# paper format for score
FORMAT = mus.A4
NONVIB_MARKUP = abjad.Markup(
[abjad.MarkupCommand("fontsize", -2.3), abjad.MarkupCommand("italic", ["non vibrato"])],
direction=abjad.enums.Up,
)
CON_SORDINO_MARKUP = abjad.Markup(
[abjad.MarkupCommand("fontsize", -2.3), abjad.MarkupCommand("italic", ["con sordino"])],
direction=abjad.enums.Up,
)
ATEMPO_MARKUP = abjad.Markup(
[abjad.MarkupCommand("fontsize", -2.3), abjad.MarkupCommand("italic", ["a tempo"])],
direction=abjad.enums.Up,
)
def main(name: str,
ignore_accidentals_higher_than_semitone: bool = True) -> None:
pitch = 7
note_duration = fractions.Fraction(1, 1)
staff = []
for nth in range(23):
diff_written = fractions.Fraction(nth - 11, 12)
diff_true = fractions.Fraction(nth - 11, 6)
note = abjad.Note(abjad.NamedPitch(pitch + diff_true), note_duration)
if diff_written == 0:
marking = None
else:
marking = "{}/{}".format(diff_written.numerator,
diff_written.denominator)
marking = abjad.MarkupCommand("fraction {} {}".format(
abs(diff_written.numerator), diff_written.denominator))
if diff_written > 0:
prefix = "+"
else:
prefix = "-"
if marking:
markup = abjad.Markup(
[abjad.MarkupCommand("abs-fontsize", 8, [prefix, marking])],
direction="up",
)
abjad.attach(markup, note)
staff.append(note)
if nth == 11:
abjad.Accidental.respell_with_flats(staff)
abjad.Accidental.respell_with_sharps(staff[17:])
if ignore_accidentals_higher_than_semitone:
staff = staff[5:18]
staff = abjad.Staff(staff)
abjad.attach(lily.mk_no_time_signature(), staff[0])
abjad.attach(abjad.TimeSignature((len(staff), 1)), staff[0])
abjad.attach(
abjad.LilyPondLiteral(
"\\override Score.SpacingSpanner.strict-note-spacing = ##t",
format_slot="before",
),
staff[0],
)
abjad.attach(
abjad.LilyPondLiteral("\\newSpacingSection", format_slot="before"),
staff[0])
abjad.attach(
abjad.LilyPondLiteral(
"\\override Score.SpacingSpanner.base-shortest-duration = #(ly:make-moment"
+ " 1/16)",
format_slot="before",
),
staff[0],
)
sco = abjad.Score([staff])
header_block = abjad.Block("header")
header_block.piece = abjad.Markup(
abjad.MarkupCommand(
"center-column",
[
abjad.MarkupCommand("fontsize", -1.5),
abjad.MarkupCommand("smallCaps"),
"12-tone accidentals",
abjad.MarkupCommand("vspace", -0.35),
],
))
lily.make_small_example(sco, name, header_block=header_block)
from mu.utils import infit
from mutools import attachments
from mutools import lily
from aml import globals_
from aml import tweaks as tw
from aml import versemaker
from aml.trackmaker import keyboard
from aml.trackmaker import strings
ARCO = attachments.StringContactPoint("arco")
PIZZ = attachments.StringContactPoint("pizzicato")
FLAUTANDO = abjad.Markup(
abjad.MarkupCommand("italic", ["flautando"]), direction=abjad.enums.Up
)
#####################################################
# post processing functions #
#####################################################
def _adapt_violin(violin: lily.NOventLine, vm) -> None:
tw.change_octave(4, 1, violin)
tw.change_octave(5, 1, violin)
tw.change_octave(6, -1, violin)
tw.change_octave(7, -1, violin)
violin[7].optional = None
violin[7].volume = 1.2
tw.split_by_structure(5, 3, violin, vm, adapt_by_changed_structure=True)
def _notate(name: str, instrument: str, scale: tuple) -> None:
for add_harmonics in (False, True):
if add_harmonics:
harmonics_dict = {
key: value[0]
for key, value in globals_.RATIO2ARTIFICAL_HARMONIC_PITCHCLASS_AND_ARTIFICIAL_HARMONIC_OCTAVE.items()
}
if instrument == "violin":
clef = abjad.Clef("treble")
header_distance = -0.4
elif instrument == "viola":
clef = abjad.Clef("alto")
header_distance = -1
elif instrument == "cello":
clef = abjad.Clef("bass")
header_distance = -1
else:
raise NotImplementedError(instrument)
staff = abjad.Staff([])
for idx, pitch in enumerate(scale):
abjad_pitch = lily.convert2abjad_pitch(pitch, globals_.RATIO2PITCHCLASS)
if add_harmonics:
(
_,
octave,
) = globals_.RATIO2ARTIFICAL_HARMONIC_PITCHCLASS_AND_ARTIFICIAL_HARMONIC_OCTAVE[
pitch.register(0)
]
harmonic_pitch = lily.convert2abjad_pitch(
pitch + ji.JIPitch([octave]), harmonics_dict
)
chord = abjad.Chord(
sorted([abjad_pitch, harmonic_pitch]), abjad.Duration(1)
)
abjad.tweak(chord.note_heads[1]).style = "harmonic"
staff.append(chord)
else:
staff.append(abjad.Note(abjad_pitch, abjad.Duration(1)))
abjad.attach(lily.mk_no_time_signature(), staff[0])
abjad.attach(abjad.TimeSignature((len(staff), 1)), staff[0])
abjad.attach(clef, staff[0])
abjad.attach(
abjad.LilyPondLiteral(
"\\override Score.SpacingSpanner.strict-note-spacing = ##t",
format_slot="before",
),
staff[0],
)
abjad.attach(
abjad.LilyPondLiteral("\\newSpacingSection", format_slot="before"), staff[0]
)
abjad.attach(
abjad.LilyPondLiteral(
"\\override Score.SpacingSpanner.base-shortest-duration ="
" #(ly:make-moment"
+ " 1/8)",
format_slot="before",
),
staff[0],
)
abjad.attach(
abjad.LilyPondLiteral("\\accidentalStyle dodecaphonic", "before"), staff[0],
)
sco = abjad.Score([staff])
if add_harmonics:
descr = "scale for {} with artificial harmonics".format(instrument)
else:
descr = "scale for {}".format(instrument)
header_block = abjad.Block("header")
header_block.piece = abjad.Markup(
abjad.MarkupCommand(
"center-column",
[
abjad.MarkupCommand("fontsize", -1.5),
abjad.MarkupCommand("smallCaps"),
descr,
abjad.MarkupCommand("vspace", header_distance),
],
)
)
final_file_name = "{}/pictures/scale_{}".format(name, instrument)
if add_harmonics:
final_file_name = "{}_artificial_harmonics".format(final_file_name)
lily.make_small_example(sco, final_file_name, header_block=header_block)
def _make_full_score_pdf_notation_for_each_instrument(self) -> None:
for paper_format in (mus.A3, mus.A4):
for meta_track in globals_.ORCHESTRATION:
notation_path = "{}/notation/full_score/{}/{}".format(
self.path, paper_format.name, meta_track)
is_first = True
for verse in self.verses:
track = getattr(verse, meta_track)
track.format = paper_format
if is_first:
track.indent_first = True
track.global_staff_size = 20
lpf = track._make_lilypond_file(
make_layout_block_global=False)
else:
track.indent_first = False
lpf.items.append(
track._make_score_block(make_layout_block=True))
last_score_block = lpf.items[-1]
instr_staff = abjad.mutate(
last_score_block.items[0][0][1]).copy()
instr_obj = globals_.INSTRUMENT_NAME2OBJECT[meta_track]
if is_first:
abjad.setting(
instr_staff).instrument_name = instr_obj.markup
else:
abjad.setting(
instr_staff
).instrument_name = instr_obj.short_markup
abjad.setting(
instr_staff
).short_instrument_name = instr_obj.short_markup
last_score_block.items[0] = abjad.Score([instr_staff])
for other_meta_track in reversed(
tuple(iter(globals_.ORCHESTRATION))):
if meta_track != other_meta_track:
other_track = getattr(verse, other_meta_track)
new_staff = abjad.mutate(
other_track.score[0][1]).copy()
if type(new_staff) == abjad.StaffGroup:
for sub_staff in new_staff:
self._detach_optional_tone_tweaks(
sub_staff)
else:
self._detach_optional_tone_tweaks(new_staff)
instr_obj = globals_.INSTRUMENT_NAME2OBJECT[
other_meta_track]
magstep = abjad.Scheme(
["magstep", self._orientation_staff_size])
abjad.override(
new_staff).staff_symbol.thickness = magstep
abjad.override(
new_staff).staff_symbol.staff_space = magstep
abjad.setting(
new_staff
).font_size = self._orientation_staff_size
if is_first:
instrument_name_markup = instr_obj.name
else:
instrument_name_markup = instr_obj.short_name
instrument_name_markup = (
instrument_name_markup[0].capitalize() +
instrument_name_markup[1:].lower())
if is_first:
short_instrument_name_markup = instr_obj.short_name
short_instrument_name_markup = (
short_instrument_name_markup[0].capitalize(
) +
short_instrument_name_markup[1:].lower())
else:
short_instrument_name_markup = instrument_name_markup
if other_meta_track == "keyboard":
instrument_name_markup = abjad.Markup([
abjad.MarkupCommand(
"fontsize",
self._orientation_staff_size),
instrument_name_markup,
])
short_instrument_name_markup = abjad.Markup([
abjad.MarkupCommand(
"fontsize",
self._orientation_staff_size),
short_instrument_name_markup,
])
else:
instrument_name_markup = abjad.Markup(
instrument_name_markup)
short_instrument_name_markup = abjad.Markup(
short_instrument_name_markup)
abjad.setting(
new_staff
).instrument_name = instrument_name_markup
abjad.setting(
new_staff
).short_instrument_name = short_instrument_name_markup
last_score_block.items[0].insert(0, new_staff)
else:
copied_staff = abjad.mutate(
last_score_block.items[0][-1]).copy()
del last_score_block.items[0][-1]
last_score_block.items[0].insert(0, copied_staff)
is_first = False
if self._title:
lpf.header_block.title = abjad.Markup(self._title)
track._notate(notation_path, lpf)
