3jgt < U d Z ddlmZ ddlmZmZ ddlZddlZddlZ ddl
Z
ddl m Z ddl m
Z
ddl mZ ddl mZ dd l mZ dd
l mZ dd l mZ dd l mZ dd
l mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddlm Z ddl m Z ddl m Z ddl m Z! ddl m"Z" ddl#m$Z$ ddl%m&Z& e jN Z' ejP d Z) G d d ejT Z+ G d d ejX Z-d Z.d Z/d Z0d!Z1d"Z2dZ3d#Z4d$Z5d%Z6d&Z7d Z8ejr e-jt e.fejv e-jt e/fejx e-jt e0fejz e-jt e1fej| e-jt e2fe j~ e-j e3fej e-j e4fej e-j e5fej e-j e6fej e-j e7fej e-j e8fg ZJd'eKd(< e-j d)e-j d*e-j d+e-j d,e-j d-e-jt d.e-j d/e-j d0iZNd1eKd2< ej ej ej ej gZSd3eKd4< G d5 d6e j ZUddd7ZVd6eKd8< d9 ZWd&ZXd:ZY ed;g d< ZZ G d= d>e j Z\ G d? d@e Z] G dA dBe"j Z_ G dC dDe_e"j ZaddEdddFddGdEddEddGdEdGdEdH dWdIZbdEdGddJ dWdKZcddFdL dXdMZd dYdNZedO ZfdZdPZgdQ Zhd[dRZid\dSZj G dT dUe
j ZlemdVk( rddl Z e j el yy)]a
Inner classes and functions for transcribing musical segments into braille.
This module was made in consultation with the manual "Introduction to Braille
Music Transcription, Second Edition" by Mary Turner De Garmo, 2005. It is
available from the Library of Congress
`here `_,
and will henceforth be referred to as BMTM.
) annotations)deque
namedtupleN)bar)base)chord)clef)dynamics) environment) exceptions21) expressionskey)layout)meter)note)spanner)stream)tempo)ProtoM21Object)basic)lookup) noteGrouping)text)BrailleTranscriptionHelper)opFracz
segment.pyc e Zd Zy)BrailleSegmentExceptionN)__name__
__module__ __qualname__ D/DATA/.local/lib/python3.12/site-packages/music21/braille/segment.pyr r : s r# r c 0 e Zd ZdZdZdZdZdZdZdZ dZ
d Z y
) Affinity
N) r r r! _LOWEST SIGNATURETTEXTMMARK
LONG_TEXTEXPRINACCORDSPLIT1_NOTEGROUP NOTEGROUPSPLIT2_NOTEGROUPr" r# r$ r& r& > s1 GI
E
EMHIr# r& r/ r. r, r( r) z4list[tuple[type[base.Music21Object], Affinity, int]]
affinityCodeszSignature GroupingzTempo Text GroupingzMetronome Mark Groupingz Long Text Expression GroupingzInaccord Groupingz
Note GroupingzSplit Note Grouping AzSplit Note Grouping Bzdict[Affinity, str]
affinityNamesz list[type[base.Music21Object]]excludeFromBrailleElementsc " e Zd ZU ded< ded< y)GroupingGlobalszkey.KeySignature | None keySignaturezmeter.TimeSignature | None
timeSignatureN)r r r! __annotations__r" r# r$ r? r? y s ''++r# r? )r@ rA GROUPING_GLOBALSc t d t j d t d< t d t j d t d< yy)z
sets defaults for grouping globals. Called first time anything
in Braille is run, but saves creating two expensive objects if never run
r@ Nr rA 4/4)rC r KeySignaturer
TimeSignaturer" r# r$ setGroupingGlobalsrH sK
'/+.+;+;A+> ((0,1,?,?,F ) 1r# 0 _ThreeDigitNumber)hundredstensonesc F e Zd ZU dZded< dZded< dZded< dZded < y)
SegmentKeyr intmeasureordinalNzAffinity | Noneaffinityz
str | Nonehand)r r r! rQ rB rR rS rT r" r# r$ rO rO s* GSGS "Hm"D(r# rO c ` e Zd ZU dZdddddddZd ed
< d Zd Zd
Zd Z d Z
d Z ddZ d Z
y)BrailleElementGroupinga
A BrailleElementGrouping mimics a list of objects which should be displayed
without a space in braille.
>>> from music21.braille import segment
>>> bg = segment.BrailleElementGrouping()
>>> bg.append(note.Note('C4'))
>>> bg.append(note.Note('D4'))
>>> bg.append(note.Rest())
>>> bg.append(note.Note('F4'))
>>> bg
,
, , ]>
>>> print(bg)
These are the defaults, and they are shared across all objects.
>>> bg.keySignature
>>> bg.timeSignature
>>> bg.descendingChords
True
>>> bg.showClefSigns
False
>>> bg.upperFirstInNoteFingering
True
>>> bg.withHyphen
False
>>> bg.numRepeats
0
zCThe last :class:`~music21.key.KeySignature` preceding the grouping.zFThe last :class:`~music21.meter.TimeSignature` preceding the grouping.zTrue if a :class:`~music21.chord.Chord` should be spelled
from highest to lowest pitch
in braille, False if the opposite is the case.zIf True, clef signs are shown in braille.
Representation of music in braille is not
dependent upon clefs and staves, so the clef signs would be displayed
for referential or historical purposes.z4If True, this grouping will end with a music hyphen.z.The number of times this grouping is repeated.)r@ rA descendingChords
showClefSigns
withHyphen
numRepeatsdict[str, str] _DOC_ATTRc t | | _ t t d | _ t d | _ d| _ d| _ d| _ d| _ d| _
y )Nr@ rA TFr ) list internalListrH rC r@ rA rW rX upperFirstInNoteFingeringrY rZ )self listElementss r$ __init__z BrailleElementGrouping.__init__ sU , / ,^ < -o > $ ")-& r# c , t | j S N)iterr_ ra s r$ __iter__z BrailleElementGrouping.__iter__ D%%&&r# c | j | S re r_ ra items r$ __getitem__z"BrailleElementGrouping.__getitem__ s &&r# c " || j |< y re rk )ra posrm s r$ __setitem__z"BrailleElementGrouping.__setitem__ s !%# r# c , t | j S re )lenr_ rg s r$ __len__z BrailleElementGrouping.__len__ s 4$$%%r# c N |dk( r t d t | j | S )Nr_ z internalList not defined yet)AttributeErrorgetattrr_ )ra attrs r$ __getattr__z"BrailleElementGrouping.__getattr__ s) > ! !?@ @t(($//r# c 2 g }d}| D ] }t |t j rf|r%|j dt j
d |D ]7 } |j dj
|j j 9 d} |j dj
|j j d} | j dkD r"|j d| j dz d | j du r%|j d
t j
d dj
| }|S # t t f$ r |j t | Y w xY w# t t f$ r |j t | Y w xY w) zo
Return a unicode braille representation
of each object in the BrailleElementGrouping.
Fzfull inaccord
full_inaccord
Tr z** Grouping x r9 z **z
music hyphen music_hyphen)
isinstancer Voiceappendr symbolsjoin editorialbrailleEnglishrv TypeErrorstrrZ rY )ra
allObjectsprevious_was_voiceobjobj2outs r$ __str__z BrailleElementGrouping.__str__ sk
#(C#v||,% %%v~~o7V6W&XY D5"))$))DNN4Q4Q*RS
&*"0 %%dii
0L0L&MN &+" ??Q t/B.C3 G H ??d "
fnn^.L-M N Oii
#
+I6 5"))#d)45 ' 2 0 %%c#h/0s$ 4D: 4E*:)E'&E'*)FFc , t | j S re )reprr_ rg s r$
_reprInternalz$BrailleElementGrouping._reprInternal ri r# N)returnr )r r r! __doc__r\ rB rc rh rn rq rt ry r r r" r# r$ rV rV sZ (T ^a ?8
MF
!I~
''&&0
<'r# rV c
e Zd ZU ddddddddd d
Zd ed < d(d) fd
Zd Zd Zd Zd Z d Z
d Z d Z e
d Zd Zd Zd Zd Zd Zd Zd*d Zd Zd+d Zd,d Z d-d Zd*d!Zd" Zd# Z d$ Z d% Z d& Z d' Z xZ!S ).BrailleSegmentzIf True, the previous key signature should be
cancelled immediately before a new key signature is encountered.zFor a given positive integer n, adds n "dummy rests"
near the beginning of a segment. Designed for test purposes, as they
are used to demonstrate measure division at the end of braille lines.zzThe maximum amount of braille characters that should be
present in a line. The standard is 40 characters.zwIf True, then a measure number is shown
following the heading (if applicable) and preceding the music.zsIf set to "right" or "left", shows the corresponding
hand sign at the beginning of the first line.zIf True, then a braille heading is displayed.
See :meth:`~music21.braille.basic.transcribeHeading`
for more details on headings.zIf True, then all octave marks are suppressed.
Designed for test purposes, as octave marks were not presented
until Chapter 7 of BMTM.a% If True, then the last
:class:`~music21.braille.segment.BrailleElementGrouping` of this
segment will be followed by a music hyphen.
The last grouping is incomplete, because a segment
break occurred in the middle of a measure.zIf True, then the initial measure number of this
segment should be followed by a dot. This segment
is starting in the middle of a measure.) cancelOutgoingKeySigdummyRestLength
lineLengthshowFirstMeasureNumbershowHand showHeadingsuppressOctaveMarks endHyphenbeginsMidMeasurer[ r\ c t | | i | _ t | _ d| _ d| _ d| _ d| _ d| _ d| _
d| _ d| _ d| _
d| _ d| _ d| _ d| _ d| _ y)a
A segment is "a group of measures occupying more than one braille line."
Music is divided into segments in order to "present the music to the reader
in a meaningful manner and to give him convenient reference points to
use in memorization" (BMTM, 71).
>>> brailleSeg = braille.segment.BrailleSegment()
>>> brailleSeg.cancelOutgoingKeySig
True
>>> brailleSeg.dummyRestLength
>>> brailleSeg.lineLength
40
>>> brailleSeg.showFirstMeasureNumber
True
Possible showHand values are None, 'right', 'left':
>>> brailleSeg.showHand is None
True
>>> brailleSeg.showHeading
True
>>> brailleSeg.suppressOctaveMarks
False
>>> brailleSeg.endHyphen
False
>>> brailleSeg.beginsMidMeasure
False
A BrailleSegment is a type of defaultdict that returns a BrailleElementGrouping
when a key is missing.
>>> len(brailleSeg.keys())
0
>>> beg = brailleSeg[braille.segment.SegmentKey(4, 1, 9)]
>>> type(beg) is braille.segment.BrailleElementGrouping
True
Of course, creating random keys like this will have consequences:
>>> print(str(brailleSeg))
---begin segment---
Measure 4, Note Grouping 2:
===
---end segment---
r NFT)superrc
_groupingDictr groupingKeysToProcesscurrentGroupingKeypreviousGroupingKeylastNoterX r` rW r r r r r r r r )ra r __class__s r$ rc zBrailleSegment.__init__2 s n J/GI8="37 48 (,
#(/3&&* $(! # &*#
#( % r# c " || j |< y re r )ra rm values r$ rq zBrailleSegment.__setitem__~ s #(4 r# c j || j vrt | j |< | j | S re )r rV rl s r$ rn zBrailleSegment.__getitem__ s4 t)) )'='?D t $!!$''r# c X || j vr| j |= y t d|d S )NzNo item z in Segment)__dict__r
ValueErrorrl s r$ __delitem__zBrailleSegment.__delitem__ s0 t}} $""4( <= =r# c . t | j | S re )rw r rl s r$ ry zBrailleSegment.__getattr__ s t))400r# c || j v S re r rl s r$ __contains__zBrailleSegment.__contains__ s t))))r# c , t | j S re )rf r rg s r$ rh zBrailleSegment.__iter__ s D&&''r# c , t | j S re )rs r rg s r$ rt zBrailleSegment.__len__ s 4%%&&r# c @ t j j | S )z@
Returns the string from the BrailleText object
)r BrailleTextr rg s r$ brailleTextzBrailleSegment.brailleText s
''--r# c
d}t | j }g }g }t }|D ] \ }} |j t j
k( r|}' |j d|j dt |j d|j dz d t | }|j | |} dj d t || D } dj d || d
g }
|
S # t $ r Y w xY w) Nz(Measure z, r9 :
r| c 3 0 K | ] \ }}| | d yw)z
===Nr" ).0kgs r$ z)BrailleSegment.__str__.. s& (
21 c!EN2s z---begin segment---z---end segment---)sorteditemsrO rS r& r6 r r rQ r< rR r r zip) ra nameallItemsallKeys allGroupingsprevKeyitemKeygroupinggStrallElementGroupingsr s r$ r zBrailleSegment.__str__ s" 9$**,' ,#+ Wh
##x'@'@@ %G A
NN7??+2 !1!1231??Q&'s,
x=D % G $, #ii (
G\2(
ii. ,,. /
%
s C00 C<;C<c F t t | j | _ | j r| j | j r| j | j | j d| _
| j r| j j | _ | j j }|t j k( r| j! n|t j" k( r| j% nk|t j& k( r| j) nG|t j* k( r| j- n#|t j. k( r| j1 | j | _
| j r| j2 S )a-
Transcribes all noteGroupings in this dict by:
* First transcribes the Heading (if applicable)
* then the Measure Number
* then adds appropriate numbers of dummyRests
* then adds the Rest of the Note Groupings
Returns brailleText
N)r r keysr r extractHeadingr extractMeasureNumberr
addDummyRestsr popleftr rS r& r7 extractNoteGroupingr1 extractSignatureGroupingr4 extractLongExpressionGroupingr5 extractInaccordGroupingr2 extractTempoTextGroupingr )ra cgkAffinityGroups r$
transcribezBrailleSegment.transcribe s? &+6$))++>%?" ! & & % % ' + #' ((&*&@&@&H&H&JD # # 6 6 ? ? 8#5#55((*!X%7%77--/!X%;%;;224!X%6%66,,.!X^^3--/'+'>'>D $ ((" r# c n |D ]0 }t j D ] }t || st || 2 y)z
Removes temporary attributes from Music21Objects set during transcription.
Run this only AFTER any possible re-transcription in extractNoteGrouping().
N)r TEMPORARY_ATTRIBUTEShasattrdelattr)ra r elkws r$ _cleanupAttributesz!BrailleSegment._cleanupAttributes s0
B002r?BO 1 r# c | j t j d z g}| j dj | y)uY
Adds as many dummy rests as self.dummyRestLength to the signatures of
brailleText
>>> seg = braille.segment.BrailleSegment()
>>> seg.dummyRestLength = 4
>>> print(braille.lookup.rests['dummy'])
⠄
>>> seg.addDummyRests()
>>> print(seg.brailleText)
⠄⠄⠄⠄
dummy N)r r rests
addSignaturesr )ra
dummyRestss r$ r z BrailleSegment.addDummyRests s7 **V\\'-BBC
277:./r# c | j xs" t t | j }|d }|j }t j | }| j r |t d z
}| j | y)u
Adds a measure number from the segmentKey needing processing
>>> segKey = braille.segment.SegmentKey(measure=4, ordinal=1, affinity=9)
>>> seg = braille.segment.BrailleSegment()
Initialize a new Key
>>> type(seg[segKey])
>>> seg.extractMeasureNumber()
>>> print(seg.brailleText)
⠼⠙
Add a dot to the measure number if the segment begins mid-measure
>>> seg = braille.segment.BrailleSegment()
>>> seg[segKey]
>>> seg.beginsMidMeasure = True
>>> seg.extractMeasureNumber()
>>> print(seg.brailleText)
⠼⠙⠄
r dotN)
r r r r rQ r numberToBrailler r addMeasureNumber)ra gkpfirstSegmentKeyinitMeasureNumber
brailleNumbers r$ r z#BrailleSegment.extractMeasureNumber so 4 ((FE&2E,F a& + 3 3 --.?@
WU^ +M m,r# c d}d}d}d}| j xs" t t | j }|r|d j t
j kD rn|j }|j }| j j | }|t
j k( rLt | dk\ r |d |d }}ndt | dk( rV|d } t | t j r| }n4| }n1|t
j k( r|d }n|t
j k( r|d }|rt! ||||g r6t# j$ ||||| j& }
| j) |
yy)a
Extract a :class:`~music21.key.KeySignature`, :class:`~music21.meter.TimeSignature,
:class:`~music21.tempo.TempoText` and :class:`~music21.tempo.MetronomeMark` and
add an appropriate braille heading to the brailleText object inputted.
Nr r: r9
maxLineLength)r r r r rS r& r3 r r getr1 rs r~ r rF r2 anyr transcribeHeadingr
addHeading) ra r@ rA tempoText
metronomeMarkr cgkr currentBrailleGrouping keyOrTimeSigbrailleHeadings r$ r z BrailleSegment.extractHeading) sg
!% : : XeF499;DW>X #$Q'008>>A'//1C "|| %)%7%7%;%;C%@ " 8#5#55-.!33I!3L3I!3L #0L/0A5#9!#'>? $(
"+ ,dii8 . 0&,,? !!%7$88_"`a12DEL ##Ay1 ,5,F,FL ))2)@)@L &5>5X5XL 2:Dgo 6"O u ; ;L I IO _ - J! #,r# c | j }| j j | }|d }t j | }| j | y)zv
Extract the Long Expression that is in the ElementGrouping in cgk
and add it to brailleText.
r N)r r r r textExpressionToBrailleaddLongExpression)ra r currentElementGroupinglongTextExpressionlongExprInBrailles r$ r z,BrailleSegment.extractLongExpressionGroupingr sR
%%!%!3!3!7!7!< 3A 6 ! 9 9:L M 01r# c R | j }| j }|||j t j k7 sk|j t j k7 sN|j
|j
k( r<|j |j dz k( r |j |j k( rd| _ | j ry|D cg c] }t |t j s |! }}d}|r;| j %|d }t j | j | }|d | _ |S c c}w )a
Given a noteGrouping, should we show the octave symbol?
>>> n1 = note.Note('C1')
>>> n2 = note.Note('D1')
>>> n3 = note.Note('E1')
>>> beg1 = braille.segment.BrailleElementGrouping([n1, n2, n3])
>>> bs1 = braille.segment.BrailleSegment()
This is True because last note is None
>>> bs1.lastNote is None
True
>>> bs1.showLeadingOctaveFromNoteGrouping(beg1)
True
But if we run it again, now we have a note within a fourth, so we do not
need to show the octave:
>>> bs1.lastNote
>>> bs1.showLeadingOctaveFromNoteGrouping(beg1)
False
And that is true no matter how many times we call it on the same
BrailleElementGrouping:
>>> bs1.showLeadingOctaveFromNoteGrouping(beg1)
False
But if we give a new, much higher BrailleElementGrouping, we
will see octave marks again.
>>> nHigh1 = note.Note('C6')
>>> nHigh2 = note.Note('D6')
>>> beg2 = braille.segment.BrailleElementGrouping([nHigh1, nHigh2])
>>> bs1.showLeadingOctaveFromNoteGrouping(beg2)
True
But if we set `self.suppressOctaveMarks` to True, we won't see any
when we switch back to beg1:
>>> bs1.suppressOctaveMarks = True
>>> bs1.showLeadingOctaveFromNoteGrouping(beg2)
False
We also show octaves if for some reason two noteGroups in the same measure have
different BrailleElementGroupings keyed to consecutive ordinals. The code simulates
that situation.
>>> bs1.suppressOctaveMarks = False
>>> bs1.previousGroupingKey = braille.segment.SegmentKey(measure=3, ordinal=1,
... affinity=braille.segment.Affinity.NOTEGROUP)
>>> bs1.currentGroupingKey = braille.segment.SegmentKey(measure=3, ordinal=2,
... affinity=braille.segment.Affinity.NOTEGROUP)
>>> bs1.showLeadingOctaveFromNoteGrouping(beg2)
True
>>> bs1.showLeadingOctaveFromNoteGrouping(beg1)
True
>>> bs1.showLeadingOctaveFromNoteGrouping(beg1)
True
Nr9 FTr r' )r r rS r& r7 rQ rR rT r r r~ r Noter showOctaveWithNote)ra r
currentKey previousKeynallNotesshowLeadingOctave firstNotes r$ !showLeadingOctaveFromNoteGroupingz0BrailleSegment.showLeadingOctaveFromNoteGrouping} s B ,,
..
# *$$(:(:: &&(*<*<< &&+*=*=="**k.A.AA.EE";+;+;; $
# # ,H|!z!TYY/GA|H }}( $QK $)$<$>> n1 = note.Note('C1')
>>> n2 = note.Note('D1')
>>> n3 = note.Note('E1')
>>> beg1 = braille.segment.BrailleElementGrouping([n1, n2, n3])
>>> seg = braille.segment.BrailleSegment()
>>> seg.needsSplitToFit(beg1)
False
>>> seg.lineLength = 10
>>> seg.needsSplitToFit(beg1)
True
r) TF)r currentLine textLocationrs )ra brailleNoteGroupingquarterLineLength spaceLefts r$ needsSplitToFitz BrailleSegment.needsSplitToFit sK & !OOq 0OOd&6&6&C&CC ) )+,/@@r# c t j }d}d}d\ }}d} ||k rSt || \ }}||_ d|_ |j | } | j j | | rn|dz
}X| j }
|
|_ |j | } | j } | j t j }
| j t j }|| |
< || |< | | fS )
z
Take a noteGrouping and split it at a logical place,
returning braille transcriptions of each section.
r r/ NNN)beatDivisionOffsetTaddSpacer9 rS )r NoteGroupingTranscribersplitNoteGroupingr rY transcribeGroupr canAppendr r _replacer& r6 r8 )ra r showLeadingOctaveOnFirstaddSpaceToFirst transcriberr! REASONABLE_LIMITsplitNoteGroupAsplitNoteGroupBbrailleNoteGroupingAr brailleNoteGroupingBr aKeybKeys r$ splitNoteGroupingAndTranscribez-BrailleSegment.splitNoteGroupingAndTranscribe s 335 -9* / # #331B #52 ._o -EK ))-O &#.#>#>#O ))*> )Y ! # $ 8 8 8(9 % * : :? K ,,
""H,E,E"F""H,E,E"F$T
$T
$&:;;r# c N t j }| j t d | j | j }| j | }||_ |j | }| j | }| j j || r | j j || n| j | }|rE | j ||| \ }}| j j || | j | |sU|du r&| j du rd|_ |j | }| j j# | j | | j% |j& | j) | y# t $ r d}Y w xY w)z^
Fundamentally important method that adds a noteGrouping to the braille line.
Nz?currentGroupingKey must not be None to call extractNoteGroupingr" FT)r r% r r r r r r' !optionalAddKeyboardSymbolsAndDotsr r( r r r4 addToNewLiner r lastHyphenToSpaceaddRepeatSymbolsrZ r ) ra r, r r r r# should_splitbngAbngBs r$ r z"BrailleSegment.extractNoteGrouping% s 335 " " * ^_ _))$*A*AB B B< P(9 % ) 9 9, G99:MN % %&9H % M # #$7( # K!%!5!56I!JL
)!%!D!D\ARAI"KJD$ $$++D8+D%%d+ %-$2J2Je2S 59K1*5*E*El*S' 224!!"56 l 5 56 -- / ) $)L)s AF F$#F$c d|cxk rdk r,n n)t | D ] }| j t d y|dk\ r6| j t d t j | z d| _ yy)u
Adds the appropriate number of repeat symbols, following DeGarmo chapter 17.
>>> seg = braille.segment.BrailleSegment()
>>> seg.addRepeatSymbols(0)
>>> print(seg.brailleText)
>>> seg.addRepeatSymbols(1)
>>> print(seg.brailleText)
⠶
>>> seg = braille.segment.BrailleSegment()
>>> seg.addRepeatSymbols(2)
>>> print(seg.brailleText)
⠶⠀⠶
>>> seg = braille.segment.BrailleSegment()
>>> seg.addRepeatSymbols(3)
>>> print(seg.brailleText)
⠶⠼⠉
Does not yet handle situations beginning with Example 17-6 (repeats at
different octaves), and further
r r( repeatN)ranger r r r r )ra repeatTimesunused_repeatCounters r$ r9 z BrailleSegment.addRepeatSymbolsZ sk 0
{ Q (-k(:$""78#45 );
A
wx 053H3H3U U V DM r# c d}d}| j }| j j | }t | dk\ r |d |d }}nUt | dk( rG| j j | j d }t |t
j r|}n|}d}| j r|
|j }t j ||| }|dk7 r| j | yy# t $ r Y :w xY w)z
Extracts a key signature, time signature, and possibly an outgoing key signature
from the currentGroupingKey and adds it to the BrailleText object.
Nr: r r9 r )
r r r rs r~ r rF r outgoingKeySigrv r transcribeSignaturesr )ra r@ rA r r r rC
brailleSigs r$ r z'BrailleSegment.extractSignatureGroupingz s
%%))--c2 | !*6q/<?-L
!
# --11$2I2IJ1ML,(8(89 + ,
$ $ )A
!-!>> SK = braille.segment.SegmentKey
>>> BS1 = braille.segment.BrailleSegment()
>>> BS1[SK(ordinal=0, affinity=2)] = ['hi', 'hello', 'there']
>>> BS1[SK(ordinal=1, affinity=9)] = ['these', 'get']
>>> BS1[SK(ordinal=2, affinity=9)] = ['put', 'together']
>>> BS1[SK(ordinal=3, affinity=4)] = ['in', 'new', 'group']
>>> BS1[SK(ordinal=4, affinity=9)] = ['with', 'the', 'previous']
>>> BS2 = BS1.consolidate()
>>> for (groupingKey, groupingList) in sorted(BS2.items()):
... print(groupingKey, groupingList)
SegmentKey(measure=0, ordinal=0, affinity=2, hand=None) ['hi', 'hello', 'there']
SegmentKey(measure=0, ordinal=1, affinity=9, hand=None) these
get
put
together
SegmentKey(measure=0, ordinal=3, affinity=4, hand=None) ['in', 'new', 'group']
SegmentKey(measure=0, ordinal=4, affinity=9, hand=None) with
the
previous
N)r r r r rS r& r7 r )ra
newSegmentpngKey groupingKey groupingListrm s r$ consolidatezBrailleSegment.consolidate s 4 $DOO4
+1$**,+? '[,##x'9'99*6
;' > (F (D v&--d3 ) ,@ r# c t j d }t j d }t | j }d\ }}|D ] \ }}||j dk\ rd|_ |j dk( r|j t j k( r|j dk( rq|j t j k( rTt |d t j rt |dd | }n t || }|r|xj dz
c_ | |= |j t j k( rJ|D ]C } t | t j r| } t | t j s;|| _ | }E n|j t j$ t j fv rt |d t j rit |d t j& t j( f rd| _ n4t |d t j, t j. f rd| _ |D
cg c] }
t |
t0 j2 s |
! } }
t5 | dk( r't | d t0 j6 r
d| d _ ||_ ||_ | j* |_ | j> |_ | j@ |_ ||}} | jB rd|_ yyc c}
w )a%
Modifies the attributes of all :class:`~music21.braille.segment.BrailleElementGrouping`
instances in a list of :class:`~music21.braille.segment.BrailleSegment` instances. The
necessary information is retrieved from the segment and from the found clef, if any.
r rE r Nr9 TF)"r rF r rG r r rR rY rS r& r7 r~ r r areGroupingsIdenticalrZ r1 rC r5
TrebleClefAltoClefrW BassClef TenorClefr GeneralNoters Rest fullMeasurer@ rA rX r` r ) ra
currentKeySigcurrentTimeSigr r previousListrK rL isRepetitionbrailleElementr allGeneralNotess r$ addGroupingAttributesz$BrailleSegment.addGroupingAttributes s{ ((+
,,U3 djjl+ &2#l+7 '[,& &&!+.2L+ ''1, ' 0 0H4F4F F ' / /1 4 ' 0 0H4F4F F!,q/499='<\!"=M|'\ '<\<'X #$//14/ - ##x'9'99&2N!.%2E2EF)7#NC4D4DE8E5(6
'3 %%(*;*;X=O=O)PP l1otyy9!,q/DOOT]]3ST04-#LOdmmT^^5TU05- /;"^ljDL\L\>]1l"^'1,OA>&*L # #_s 3 K+K+c ddl m fd}| j }|j D cg c]$ }|j t
j k( r|| & }}|D ] }|D cg c] }t |t j s |! }}t t | D ]P }|| } | j D ]: }
t |
j rt |
j s0 ||
| || < R yc c}w c c}w )a
Goes through each :class:`~music21.braille.segment.BrailleSegment` and modifies the
list of :attr:`~music21.note.GeneralNote.articulations` of a :class:`~music21.note.Note`
if appropriate. In particular, two rules are applied:
* Doubling rule => If four or more of the same :class:`~music21.articulations.Articulation`
are found in a row, the first instance of the articulation is doubled and the rest are
omitted.
It is permissible (not mandatory) to observe this doubling with bowings. (BMTM, 114)
For this reason, any :class:`~music21.articulations.TechnicalIndication` but for bowings
(e.g. fingering, harmonic) is skipped, because it does not braille as an articulation.
* Staccato, Tenuto rule => "If two repeated notes appear to be tied, but either is marked
staccato or tenuto, they are treated as slurred instead of tied." (BMTM, 112)
r )
articulationsc | j }t |
j
j f r[|j O|j j
dk( rd ||dz
_ d||dz
_ nd ||dz _ d|_ d |_ d}t |dz t | D ]4 }|| }||j D cg c] }|j c}v r|dz
}4 n |dk ry |j j | t |dz ||z D ]C }|| }|j D ]- } | j |k( s|j j | / E y c c}w )Nstopr9 Tr r( ) r r~ StaccatoTenutotietype shortSlurr? rs r_ r remove) articmusic21NoteStartr noteIndexStart articName
numSequentialnoteIndexContinuemusic21NoteContinueaartOtherr_ s r$ fixOneArticulationz;BrailleSegment.fixArticulations..fixOneArticulation sw
I5=#9#9=;O;O"PQ(,,8#'',,67;H^a /04=AH^a /0:7;H^a /0415$.'+ $ M%*>A+=s8}%M!&./@&A# 1D1R1R S1RA1R SS!Q&M &N q
* * 1 1% 8%*>A+=+9M+I&K!&./@&A# 3 A AH }} 1+99@@J !B&K !Ts <EN)music21r_ rM r rS r& r7 r~ r r r? rs TechnicalIndicationBowing) ra rq rI gpKey
noteGroupingsr r allNotes_outernoteIndexStart_outermusic21NoteStart_outer artic_outerr_ s @r$ fixArticulationsz BrailleSegment.fixArticulations s " * K< %%'
*4//*;I*;#(>>X5G5G#G $E**; I *L)5 R AAtyy9Qa N R(-c..A(B$)78L)M #G#GK &{M4U4U V )+}7K7K L* ' 2 * 0 $H )C *I Ss )C3# C8C8( r rP )r None)r rV )r bool)FF)"r r r! r\ rB rc rq rn r ry r rh rt propertyr r r r r r r r r r r r4 r r9 r r rM r] r{
__classcell__)r s @r$ r r s !U ZF#SB2 -?
1*(' . . D( T$0"!-F-,` 2 2^!@: AF7<+$%N5+nAr# r c H e Zd ZdZd
d dZed Zd Zd Zd Z d Z
d Z y ) BrailleGrandSegmenta
A BrailleGrandSegment represents a pair of segments (rightSegment, leftSegment)
representing the right and left hands of a piano staff (or other two-staff object).
>>> bgs = braille.segment.BrailleGrandSegment(lineLength=36)
>>> bgs.lineLength
36
c t j | | t j j | | t | _ d | _ d | _ y )Nr )r rc r BrailleKeyboardr allKeyPairspreviousGroupingPaircurrentGroupingPair)ra r s r$ rc z BrailleGrandSegment.__init__N sK < %%dz%B:?'
$(!#' r# c @ t j j | S re )r r r rg s r$ r z BrailleGrandSegment.brailleTextV s ##++D11r# c d}g }| j D ] \ }}|ld|j dt |j d|j dz d}t | j j | }dj ||g }nd}|ld|j d t |j d|j dz d}t | j j | } dj || g }
nd}
|j d
j ||
d g d
j d |dj | d
g } | S )Nz1
===r z Right, r r9 r r z
Measure z Left, r| z====
z---begin grand segment---z---end grand segment---)
yieldCombinedGroupingKeysrQ r< rS rR r r r r r ) ra r allPairsrightKeyleftKey rightHeading
rightContents rightFull leftHeading leftContentsleftFullr s r$ r zBrailleGrandSegment.__str__Z sd C#'#A#A#C Xw# x / / 0$X%6%678 ''!+,C1
!$D$6$6$:$:8$D E
GG\=$A B " 1$W%5%567q *+30
#4#5#5#9#9'#B C 77K #>? OODIIy(H&E F G+ $D, ii4 *24 5
r# c # ( K d }d }d}d}t | j | D ] }|j dk( rk|f ||| r||f nS|j t j
k( r. ||j
t j | r||f nd|f |}d}z|}}|j dk( s|E ||| r||f n2|j t j k r
|df d|f n|df |}d}|} |r|df |rd|f yyw)a
yields all the keys in order as a tuple of (rightKey, leftKey) where
two keys are grouped if they have the same segmentKey except for the hand.
>>> bgs = braille.segment.BrailleGrandSegment()
>>> SegmentKey = braille.segment.SegmentKey # namedtuple
>>> bgs[SegmentKey(1, 1, 1, 'right')] = '1r'
>>> bgs[SegmentKey(1, 1, 1, 'left')] = '1l'
>>> bgs[SegmentKey(1, 2, 3, 'right')] = '2r'
>>> bgs[SegmentKey(1, 2, 4, 'left')] = '3l'
>>> bgs[SegmentKey(2, 1, 9, 'left')] = '4l'
>>> bgs[SegmentKey(2, 1, 9, 'right')] = '4r'
>>> bgs[SegmentKey(3, 1, 9, 'right')] = '5r'
>>> for l, r in bgs.yieldCombinedGroupingKeys():
... (bgs[l], bgs[r])
('1r', '1l')
('2r', )
(, '3l')
('4r', '4l')
('5r', )
Known Bug:
Because this puts `None` elements into the defaultDict,
it makes the assumption that all of .keys() will be SegmentKeys
incorrect. In fact, if you run this method twice, the second time
it will crash.
c r | j dk( rd}nd}| j | j | j |fS )z\
sort by measure, then ordinal, then affinity, then hand (r then l)
rightr' r9 )rT rQ rR rS )
segmentKeyskHs r$ segmentKeySortKeyzHBrailleGrandSegment.yieldCombinedGroupingKeys..segmentKeySortKey s< ') &&
(:(:J.matchOther sD %%)9)99%--1A1AA%..(2C2CC r# Nr r r$ left)r r rT rS r& r7 r) r5 )ra r r storedRight
storedLeftthisKeys r$ r z-BrailleGrandSegment.yieldCombinedGroupingKeysy sD > V
diik/@AG||w& )!':6 &
33!**h.@.@@ ()9)98CTCT)9)UWa b '
33 #Z 00&- !%J")K ' *!';7 *G 44$--0A0AA *D 11 #Wo- *D 11%,
"&K!(J9 B< % % $ $ s
B2D5A Dc f t | j | _ | j d }|d r|d j n|d j }t t | | _ | j d| _ | j r| j | _ | j j | _ | j \ }}| |j t j k\ s |-|j t j k\ r| j | j r| j S )zI
Returns the BrailleText from the combined grouping keys
r' r r9 N)r r r rQ rs r highestMeasureNumberLengthr r r r rS r& r5 r r )ra lastPairhighestMeasurer r s r$ r z BrailleGrandSegment.transcribe s !!?!?!AB##B'08 !,,!ATAT*-c..A*B' #' (,(@(@D %'+'7'7'?'?'AD $"&":": Xw%(*;*;x?P?P*P +0@0@HDUDU0U((* r# c d}d}d}d}| j r| j d \ }}|} | j j | }|j
t j kD rn| j j |j
t j k( r |d |d }}nE|j
t j k( r|d }n"|j
t j k( r|d }| j r t j ||||| j" }
| j% |
y# t $ r=} | j d dk( r | j j | }|}n| Y d} ~ +d} ~ ww xY w# t $ r( t |t j r|d }n|d }Y w xY w# t j& $ r } | j d dk7 r| Y d} ~ yd} ~ ww xY w)z
Finds KeySignatures, TimeSignatures, TempoText, and Metronome Marks
within the keyPairs, and removes some from allKeyPairs.
Nr r r9 r zNo heading can be made.)r r r KeyErrorargsrS r& r3 r r1
IndexErrorr~ r rF r2 r r r r BrailleBasicException) ra r@ rA r r r r useKey
useElementker bbes r$ r z"BrailleGrandSegment.extractHeading s
"&"2"21"5 Xw F
! / / 3 3H =
/ $ $ &("4"4462.>?'1!} (21
6& ** xx{ 77 8 sA D/
E8 95F, / E582E00E58.F)(F),G ?GG c j \ }}|r
|j }n|r
|j }n t d t j |d } fd} || } || } j ||| y )Nz/Measure must be defined for leftKey or rightKeyF)withNumberSignc l | | j t j k( r̉j j | }g }|D ] }t |t j s t | }|j |_ |j |_
|j |_ |j t j | j | t d j# | }|S | Cj j | }t j | }j | |S d}|S )Nr{ r )rS r& r5 r r r~ r r r rW rX r` r r r r r r )rightOrLeftKeyr voice_trans music21Voicer
brailleStrra s r$ brailleFromKeyz?BrailleGrandSegment.extractNoteGrouping..brailleFromKeyX s )n.E.EIZIZ.Z . . 2 2> B $-L%lFLLA #9,#GL4=4N4NL11:1H1HL.=F=`=`L: &&u'C'CL'QR++L9 %. %_ 5 : :; G
+ # 1 1 5 5n E " 9 9, G
'' 5
r# )r rQ r r r addNoteGroupings)ra r r mNumcurrentMeasureNumberr rhBraille lhBrailles ` r$ r z'BrailleGrandSegment.extractNoteGroupingM sz " 6 67 ##D
??D NO O $ 4 4T% P 0 #8, "7+ 2IyIr# Nr| r~ ) r r r! r rc r r r r r r r r" r# r$ r r E s= ( 2 2 >T%J :0d&Jr# r Tr} F)setHandr rW r r
segmentBreaksrX r r r showLongSlursAndTiesTogether showShortSlursAndTiesTogetherslurLongPhraseWithBracketsr r` c t | | | |
t | || }|D ]a }||_ ||_ ||_ |j ||_ ||_ ||_ | |_ |
|_
||_ |j c |S )u'
Takes in a :class:`~music21.stream.Part`.
Returns a list of :class:`~music21.segment.BrailleSegment` instances.
Five functions or methods get called in the generation of segments:
* :func:`~music21.braille.segment.prepareSlurredNotes`
* :func:`~music21.braille.segment.getRawSegments`
* :meth:`~music21.braille.segment.BrailleSegment.addGroupingAttributes`
* :meth:`~music21.braille.segment.BrailleSegment.addSegmentAttributes`
* :meth:`~music21.braille.segment.BrailleSegment.fixArticulations`
>>> from music21.braille import test
>>> example = test.example11_2()
>>> allSegments = braille.segment.findSegments(example)
>>> print(str(allSegments[0]))
---begin segment---
Measure 0, Signature Grouping 1:
===
Measure 0, Note Grouping 1:
===
Measure 1, Note Grouping 1:
===
Measure 2, Note Grouping 1:
===
Measure 3, Note Grouping 1:
===
Measure 4, Note Grouping 1:
===
Measure 5, Note Grouping 1:
===
Measure 6, Note Grouping 1:
===
Measure 7, Note Grouping 1:
===
Measure 8, Note Grouping 1:
music hyphen ⠐
===
---end segment---
Second segment
>>> print(str(allSegments[1]))
---begin segment---
Measure 8, Note Grouping 2:
===
Measure 9, Note Grouping 1:
===
Measure 10, Note Grouping 1:
===
Measure 11, Note Grouping 1:
===
Measure 12, Note Grouping 1:
===
Measure 13, Note Grouping 1:
===
Measure 14, Note Grouping 1:
===
Measure 15, Note Grouping 1:
===
Measure 16, Note Grouping 1:
===
Measure 17, Note Grouping 1:
===
---end segment---
)r r r r r )
prepareSlurredNotesgetRawSegmentsrX r` rW r] r r r r r r r{ ) music21Partr r rW r r r rX r r r r r r r r` allSegmentssegs r$ findSegmentsr s j 5Q6S3M !g][K *(A% / !!# $8 -%;" %"5 ' * r# )r r r c | j sy||}| j j j }| j j t
j D ] }|j }|j } |j | }|j | } t | |z
dz }
|si|
t k r`|| j !|| j j dk( r|dz
}|| j !|| j j dk( r| dz } |si|
t kD r`|| j !|| j j dk( r|dz
}|| j !|| j j dk( r| dz } |
t k r t! || D ] } d|| _ T|rd|| _ d|| _ ld||dz _ d|| dz
_ y# t j $ r Y w xY w)aF
Takes in a :class:`~music21.stream.Part` and three keywords:
* slurLongPhraseWithBrackets
* showShortSlursAndTiesTogether
* showLongSlursAndTiesTogether
For any slurs present in the Part, the appropriate notes are labeled
with attributes indicating where to put the symbols that represent
slurring in braille. For purposes of slurring in braille, there is
a distinction between short and long phrases. In a short phrase, a
slur covers up to four notes. A short slur symbol should follow each
note except the last.
>>> import copy
>>> from music21.braille import segment
>>> short = converter.parse('tinynotation: 3/4 c4 d e')
>>> s1 = spanner.Slur(short.recurse().notes.first(), short.recurse().notes.last())
>>> short.append(s1)
>>> short.show('text')
{0.0}
{0.0}
{0.0}
{0.0}
{1.0}
{2.0}
{3.0}
{3.0} >
>>> shortA = copy.deepcopy(short)
>>> segment.prepareSlurredNotes(shortA)
>>> shortA.recurse().notes[0].shortSlur
True
>>> shortA.recurse().notes[1].shortSlur
True
In a long phrase, a slur covers more than four notes. There are two
options for slurring long phrases. The first is by using the bracket
slur. By default, slurLongPhraseWithBrackets is True. The opening
bracket sign is put before the first note, and the closing bracket
sign is put before the last note.
>>> long = converter.parse('tinynotation: 3/4 c8 d e f g a')
>>> s2 = spanner.Slur(long[note.Note].first(), long[note.Note].last())
>>> long.append(s2)
>>> long.show('text')
{0.0}
{0.0}
{0.0}
{0.0}
{0.5}
{1.0}
{1.5}
{2.0}
{2.5}
{3.0}
{3.0} >
>>> longA = copy.deepcopy(long)
>>> segment.prepareSlurredNotes(longA)
>>> longA[note.Note].first().beginLongBracketSlur
True
>>> longA[note.Note].last().endLongBracketSlur
True
The other way is by using the double slur, setting `slurLongPhraseWithBrackets`
to False. The opening sign of the double slur is put after the first note
(i.e. before the second note) and the closing sign is put before the last
note (i.e. before the second to last note).
If a value is not supplied for `showLongSlursAndTiesTogether`, it will take the
value set for `slurLongPhraseWithBrackets`, which defaults True.
>>> longB = copy.deepcopy(long)
>>> segment.prepareSlurredNotes(longB, slurLongPhraseWithBrackets=False)
>>> longB.recurse().notes[1].beginLongDoubleSlur
True
>>> longB.recurse().notes[-2].endLongDoubleSlur
True
In the event that slurs and ties are shown together in print, the slur is
redundant. Examples are shown for slurring a short phrase; the process is
identical for slurring a long phrase.
Below, a tie has been added between the first two notes of the short phrase
defined above. If showShortSlursAndTiesTogether is set to its default value of
False, then the slur on either side of the phrase is reduced by the amount that
ties are present, as shown below.
>>> short.recurse().notes[0].tie = tie.Tie('start')
>>> shortB = copy.deepcopy(short)
>>> segment.prepareSlurredNotes(shortB)
>>> shortB.recurse().notes[0].shortSlur
Traceback (most recent call last):
AttributeError: 'Note' object has no attribute 'shortSlur'
>>> shortB.recurse().notes[0].tie
>>> shortB.recurse().notes[1].shortSlur
True
If showShortSlursAndTiesTogether is set to True, then the slurs and ties are
shown together (i.e. the note has both a shortSlur and a tie).
>>> shortC = copy.deepcopy(short)
>>> segment.prepareSlurredNotes(shortC, showShortSlursAndTiesTogether=True)
>>> shortC.recurse().notes[0].shortSlur
True
>>> shortC.recurse().notes[0].tie
TODO: This should not add attributes to Note objects but instead return a collection
of sets of notes that have each element applied to it.
Nr9 startra T)
spannerBundleflattennotesr
getByClassr SlurgetFirstgetLastindexr StreamExceptionabs SEGMENT_MAXNOTESFORSHORTSLURrd re r? rf beginLongBracketSlurendLongBracketSlurbeginLongDoubleSlurendLongDoubleSlur) r r r r r slurr r
beginIndexendIndexdelta noteIndexs r$ r r < s j $ $#+'A$""$**113H))44W\\BMMO <<> ! 2J ~~h/H Hz)*Q.,:V1V $((4 ,0055@a
!%%1hx6H6L6L6Q6QU[6[A
+8T0T$((4 ,0055@a
!%%1hx6H6L6L6Q6QU[6[A
0 0 ":x 8 04#- 9 *<@$98<"5?Ca (<;?A &8Q C ++
s "G--HHr c 2 g }t | }d}d}| j t j D ] }t | t | }d} t j }
|D ] } |rd| j dk7 rd|_ |j | t | }| j dk7 rd|_ d}|
t j ur| dz
} d}d| j v r d| j v r
|t k rn|dkD rd}t | t j r|t kD r| j" d v rd}| j$ j& |
k r| dz
} | j$ j& } | t j( k( rt j* } n#| t j, k( rt j. } t1 |j2 | | | }
|
|vr
t5 ||
< ||
}|j | |dz
}| j$ j& }
|j | |S )
a
Takes in a :class:`~music21.stream.Part`, divides it up into segments (i.e. instances of
:class:`~music21.braille.segment.BrailleSegment`). This function assumes
that the Part is already divided up into measures
(see :class:`~music21.stream.Measure`). An acceptable input is shown below.
This will automatically find appropriate segment breaks at
:class:`~music21.braille.objects.BrailleSegmentDivision`
or :class:`~music21.braille.objects.BrailleOptionalSegmentDivision`
or after 48 elements if a double bar or repeat sign is encountered.
Two functions are called for each measure during the creation of segments:
* :func:`~music21.braille.segment.prepareBeamedNotes`
* :func:`~music21.braille.segment.extractBrailleElements`
>>> tn = converter.parse("tinynotation: 3/4 c4 c c e e e g g g c'2.")
>>> tn = tn.makeNotation(cautionaryNotImmediateRepeat=False)
>>> tn.show('text')
{0.0}
{0.0}
{0.0}
{0.0}
{1.0}
{2.0}
{3.0}
{0.0}
{1.0}
{2.0}
{6.0}
{0.0}
{1.0}
{2.0}
{9.0}
{0.0}
{3.0}
By default, there is no break anywhere within the Part,
and a segmentList of size 1 is returned.
>>> import copy
>>> from music21.braille import segment
>>> tnA = copy.deepcopy(tn)
>>> rawSegments = segment.getRawSegments(tnA)
>>> len(rawSegments)
1
>>> rawSegments[0]
>>> print(rawSegments[0])
---begin segment---
Measure 1, Signature Grouping 1:
===
Measure 1, Note Grouping 1:
===
Measure 2, Note Grouping 1:
===
Measure 3, Note Grouping 1:
===
Measure 4, Note Grouping 1:
===
---end segment---
Now, a segment break occurs at measure 2, offset 1.0 within that measure.
The two segments are shown below.
>>> tnB = copy.deepcopy(tn)
>>> tnB.measure(2).insert(1.0, braille.objects.BrailleSegmentDivision())
>>> allSegments = segment.getRawSegments(tnB)
>>> len(allSegments)
2
>>> allSegments[0]
>>> print(allSegments[0])
---begin segment---
Measure 1, Signature Grouping 1:
===
Measure 1, Note Grouping 1:
===
Measure 2, Note Grouping 1:
===
---end segment---
>>> allSegments[1]
>>> print(allSegments[1])
---begin segment---
Measure 2, Note Grouping 2:
===
Measure 3, Note Grouping 1:
===
Measure 4, Note Grouping 1:
===
---end segment---
If we insert an optional division, the division
only appears if there are 48 elements in the current segment:
>>> tnC = copy.deepcopy(tn)
>>> tnC.measure(1).insert(1.0, braille.objects.BrailleOptionalSegmentDivision())
>>> allSegments = segment.getRawSegments(tnC)
>>> len(allSegments)
1
If by happenstance a segment division object is encountered where a division
has just been created (or the very beginning),
no unnecessary empty segment will be created:
>>> tnD = copy.deepcopy(tn)
>>> tnD.measure(1).insert(0, braille.objects.BrailleSegmentDivision())
>>> allSegments = segment.getRawSegments(tnD)
>>> len(allSegments)
1
r r F Tr9 BrailleSegmentDivision BrailleOptionalSegmentDivision)doublefinal)r getElementsByClassr MeasureprepareBeamedNotesr r& r0 offsetr r r classesMAX_ELEMENTS_IN_SEGMENTr~ r Barlinere r affinityCoder6 r5 r8 r7 rO numberrV )r r r r currentSegmentelementsInCurrentSegmentstartANewSegmentmusic21MeasurebrailleElementsrR previousAffinityCoder[ r r brailleElementGroupings r$ r r s! p K#}=N$% "%88 H>*0 @ ' / / -N !((C/ 04N, "">2!/=!I!((C/6:N3+,('x/?/??qLG#( '>+A+AA48N8NN 48O O-1'+$>3;;7,/FF"''+>> $( ''447KK1 )33@@Lx 8 88 ' 0 0 !:!:: ' 1 1 #N$9$9$+$0$+&J
/-C-Ez*%3J%? " " ) ). 9 $ ) $ $2#;#;#H#H w .
ID ~& r# c t }d}| D ] }t |t j r|}! t |t j
r|j dk( rLt | |t |t j t j f r^t | |j j |j _
t | g|j _ |j! | d}|j! | t | g|j _ |j- d t/ | dk\ rWt |d t0 j2 r:t |d t j
r d|d _ |j- d |S # t" $ rO}t$ D cg c] }t || nc c}w }}t' | st( j+ | Y d}~d}~ww xY w) a0
Takes in a :class:`~music21.stream.Measure` or :class:`~music21.stream.Voice`
and returns a :class:`~music21.braille.segment.BrailleElementGrouping` of correctly ordered
:class:`~music21.base.Music21Object` instances which can be directly transcribed to
braille.
>>> from music21.braille import segment
>>> tn = converter.parse('tinynotation: 2/4 c16 c c c d d d d', makeNotation=False)
>>> tn = tn.makeNotation(cautionaryNotImmediateRepeat=False)
>>> measure = tn[0]
>>> measure.append(spanner.Slur(measure.notes[0],measure.notes[-1]))
>>> measure.show('text')
{0.0}
{0.0}
{0.0}
{0.25}
{0.5}
{0.75}
{1.0}
{1.25}
{1.5}
{1.75}
{2.0} >
{2.0}
Spanners are dealt with in :func:`~music21.braille.segment.prepareSlurredNotes`,
so they are not returned by this function, as seen below.
>>> print(segment.extractBrailleElements(measure))
Nregularc 2 | j | j fS re r classSortOrderxs r$ z(extractBrailleElements.. s AHHa.>.>#?r# r r: r' c 2 | j | j fS re r r s r$ r z(extractBrailleElements.. s AHHa6F6F+Gr# )rV r~ r r r r re setAffinityCoder rT r r r r r r r r r= r r r sortrs r
Dynamicr )music21MeasureOrVoice allElementsr
music21ObjectnotSupportedException music21ClassisExempts r$ r r s X )*K $I.
mTYY /%I >-5 %%2 M *$!D$4$4fll#C*E *3@3J3J3W3W ##069)n5E ##2""9- } -69-6H5IM # # 2- /< ?@
;1 KOX=M=M!N k"os{{ 3-/KO * !G H ' >,FH,FL #=,?,FHH Hx= !!%:$;= >s* )FCF G1"G,*F>=)G,,G1c x | j j }|D ] }d|_ d|_ | j j }d }d }d }|j j
| j
| }|j j
| j
| }t | t | k7 rt j d yt | D ] \ } }
|
j dk( r|| } |j |
} |j | }
|
| z
dz }|d k rLd
}t | dz |
dz D ]? }|| j |
j k7 s t || t j s=d} n ||
dz }t |t j r-t# |j$ t# | j$ k( rd}|s ||
dz j dk( r
d
|
_ || dz
}t |t j rKt# |j$ t# |
j$ k( r |j |
j k( rd
|
_ t | dz |
dz D ] }d
|| _ y# t& $ r Y w xY w# t& $ r Y w xY w# t& $ r Y Nw xY w) a#
Takes in a :class:`~music21.stream.Measure` and labels beamed notes
of smaller value than an 8th with beamStart and beamContinue keywords
in accordance with beaming rules in braille music.
A more in-depth explanation of beaming in braille can be found in
Chapter 15 of Introduction to Braille Music Transcription, Second
Edition, by Mary Turner De Garmo.
>>> from music21.braille import segment
>>> tn = converter.parse('tinynotation: 2/4 c16 c c c d d d d')
>>> tn = tn.makeNotation(cautionaryNotImmediateRepeat=False)
>>> tn.show('text')
{0.0}
{0.0}
{0.0}
{0.0}
{0.25}
{0.5}
{0.75}
{1.0}
{1.25}
{1.5}
{1.75}
{2.0}
>>> measure = tn[0]
>>> segment.prepareBeamedNotes(measure)
>>> measure.notes[0].beamStart
True
>>> measure.notes[1].beamContinue
True
>>> measure.notes[2].beamContinue
True
>>> measure.notes[3].beamContinue
True
Fc R | j d uxr t | j dkD S )Nr )beamsrs r unuseds r$ withBeamFilterz*prepareBeamedNotes..withBeamFilterI s# $;#bhh-!*;;r# c R | j j d j dk( S )Nr9 r r getByNumberre r
s r$ beamStartFilterz+prepareBeamedNotes..beamStartFilterL s" xx##A&++w66r# c R | j j d j dk( S )Nr9 ra r r
s r$ beamStopFilterz*prepareBeamedNotes..beamStopFilterO s" xx##A&++v55r# zDIncorrect beaming: number of start notes != to number of stop notes.Ng ?r9 r( T)r r beamStart beamContinue
notesAndRestsrf addFilterrs r r enumerate
quarterLengthr r? r~ r rU rP beatr )r r
sampleNoteallNotesAndRestsr r r allStartIter allStopIter beamIndex startNotestopNote
startIndex stopIndexr allNotesOfSameValuer
afterStopNotebeforeStartNotes r$ r r s J ##**,H
$
"'
&33::<<76 ==?,,^<FFWL--/++N;EEnUK
<C ,,`a ), 7 9 " "c ) y)%++I6
$**84 J&* 19 # zA~y1}=I +99Y=T=TT!"29"=tyyI&+# >
,Y] ;M=$))4 ] / /0C
4FF&+# # A
.<<C D
# .zA~ >O?DII6O 0 01S 5HH'559P9PP)- & zA~y1}=I7; Y ' 4 >c !86 s8
AJ J =A-J- JJ J*)J*- J98J9c t D ], \ }}}t | | s|| j _ || _ y t | t
j rlt j | j _ t | j j dkD r t j | j _ d| _ yt | t ryt | d )ab
Takes in a :class:`~music21.base.Music21Object`, and does two things:
* Modifies the :attr:`~music21.base.Music21Object.classSortOrder` attribute of the
object to fit the slightly modified ordering of objects in braille music.
* Adds an affinity code to the Editorial for the object.
This code indicates which surrounding objects the object should be grouped with.
A BrailleSegmentException is raised if an affinity code cannot be assigned to
the object.
As seen in the following example, the affinity code of a :class:`~music21.note.Note`
and a :class:`~music21.clef.TrebleClef` are the same, because they should be grouped
together. However, the classSortOrder indicates that the TrebleClef should come first
in the braille.
>>> n1 = note.Note('D5')
>>> braille.segment.setAffinityCode(n1)
>>> n1.editorial.affinityCode
>>> n1.classSortOrder
10
>>> c1 = clef.TrebleClef()
>>> braille.segment.setAffinityCode(c1)
>>> c1.editorial.affinityCode
>>> c1.classSortOrder
7
Nr9 r- z" cannot be transcribed to braille.)r; r~ r r r r
TextExpressionr& r7 rs contentsplitr4 r r )r r code sortOrders r$ r r s > ,9' tY m\ 237M # # 0+4M ( ,9 -!;!;>> a = [note.Note('C4'), note.Note('D4')]
>>> b = [note.Note('C4'), note.Note('D4')]
>>> braille.segment.areGroupingsIdentical(a, b)
True
>>> d = b.pop()
>>> braille.segment.areGroupingsIdentical(a, b)
False
>>> c = [note.Rest(), note.Note('D4')]
>>> braille.segment.areGroupingsIdentical(a, c)
False
FT)rs r )
noteGroupingA
noteGroupingBelementAelementBs r$ rO rO s@ * =S //$'
}$E Xx8# %F r# c | t j }| D ] }|j |j | t ||| j
\ }}t
j | }g |_ |D ] }|j | t
j | }g |_ |D ] }|j | ||fS )a
Almost identical to :func:`~music21.braille.segment.splitMeasure`, but
functions on a :class:`~music21.braille.segment.BrailleElementGrouping`
instead.
>>> from music21.braille import segment
>>> bg = segment.BrailleElementGrouping()
>>> bg.timeSignature = meter.TimeSignature('2/2')
>>> s = converter.parse('tinyNotation: 2/2 c4 d r e')
>>> for n in s.recurse().notesAndRests:
... bg.append(n)
>>> left, right = segment.splitNoteGrouping(bg)
>>> left
, ]>
>>> print(left)
>>> right
, ]>
Now split one beat division earlier than it should be. For 2/2 that means
one half of a beat, or one quarter note earlier:
>>> left, right = segment.splitNoteGrouping(bg, beatDivisionOffset=1)
>>> left
]>
>>> right
, , ]>
) r r r r splitMeasurerA copyr_ r )r r! r r[ leftMeasure rightMeasureleftBrailleElementsrightBrailleElementss r$ r& r& s H ^^%N& n 3 3^D '".~/A/;/I/I#K [, ))L1')$%"">2 & 99\2(*%& ##N3 ' 4 44r# c ||}n| j }d}|dk7 rt | t |j kD rt d| d|j t |j t | z
} |t |j | j z
}t | }t j |j }d} |j |d |j d \ }} | |z } t% j& }
t% j& } | D ] } | j( |k\ rU| j( | k s)| j( | k( r7t+ | t, j. r |
j1 | j( | g| j1 | j( | | j2 D ]K }
|
j4 <|
j7 |
| j9 |
| |
j: j z
} K n | j: j | z
}t= j> |
}|
j1 | | t= j> |
}| j1 d| d}|
j@ d}||
_ || _ |
jC | | jC | |
jE d | jE d tG |
tG | |
j9 | | j9 | |r|
j9 | | j9 | |
| fS # t $ r' t j d| j d Y w xY w# t j" $ rH |d
z
}|j |d |j d d }|j d d } Y w xY w)aS
Takes a :class:`~music21.stream.Measure`, divides it in two parts, and returns a
two-tuple of (leftMeasure, rightMeasure). The parameters are as
follows:
* beatDivisionOffset => Adjusts the end offset of the first partition by a certain amount
of beats to the left.
* useTimeSignature => In the event that the Measure comes from the middle of a Part
and thus does not define an explicit :class:`~music21.meter.TimeSignature`. If not
provided, a TimeSignature is retrieved by
using :meth:`~music21.stream.Measure.bestTimeSignature`.
>>> m = stream.Measure()
>>> m.append(note.Note('C4'))
>>> m.append(note.Note('D4'))
>>> left, right = braille.segment.splitMeasure(m)
>>> left.show('text')
{0.0}
>>> right.show('text')
{1.0}
r r zbeatDivisionOffset z( is outside of ts.beatDivisionDurations z2Problem in converting a time signature in measure z, offset may be wrongr: F) loadDefaultr9 r r' )r T)inPlace)$bestTimeSignaturer rs beatDivisionDurationsr r r r r r r r6 deepcopy beatSequencepartitionByCount getLevelSpanr MeterExceptionr r r r~ r r r r rd r rg durationr rU rA mergeAttributes makeBeamsr )r r! useTimeSignaturetsr duration_indexbsnumberOfPartitionsstartOffsetZero
endOffsetZeror7 r8 r r rest0Lengthr0r1
ts0_deletes r$ r5 r5 s , #
-
-
/
FQ ! "S)A)A%B B)%&8%9 ://1/G/G.HJ
R 5 56=O9PP O fR 5 5n E S ST TFF^F
r 'B2
.EB+-??+>#L
HH 'XX
-]2 '3;; 7 qxx + ! ,
55 q ! " QZZ 5 5 5M
!))77-GK
-B}b)
/BR J (
$& !!#L / 0$'4({#|$r2 &&s O R!/!6!6 77L N
O O 2a
.EB //+A.q1)"-b1
2s% ;0L1
)M$ 1,M! M!$AN?>N?c e Zd Zd Zy)Testc ddl m} |j d }|j d }t | }t |d }y )Nr ) converterz)tinynotation: 3/4 c4 c c e e e g g g c'2.F) cautionaryNotImmediateRepeat)rr rV parse makeNotationr r )ra rV tn
rawSegListr s r$ testGetRawSegmentszTest.testGetRawSegments~ s< %
__ H
I
__%_
@#B'
Z]#r# N)r r r! r\ r" r# r$ rT rT | s $r# rT __main__)r z bool | None)r rP )r z stream.Measure | stream.Voicer rV )r zbase.Music21Object)r )r N)or
__future__r collectionsr r r6 enumtypingtunittestrr r r r r r
r r r
r r r r r r r music21.prebaser music21.brailler r r r r music21.braille.objectsr music21.common.numberToolsr r Environmentr Music21Exceptionr IntEnumr& CSO_NOTECSO_REST CSO_CHORD CSO_DYNAMICCSO_CLEF CSO_BARLINE
CSO_KEYSIG CSO_TIMESIG CSO_TTEXT CSO_MMARK CSO_VOICEr r7 rU Chordr r r r8 rF r1 rG TempoTextr2
MetronomeMarkr3 r r5 r; rB r4 r6 r< r SystemLayout
PageLayout StaffLayoutr= TypedDictr? rC rH r r rJ
NamedTuplerO rV r r r r r r r r r r rO r& r5 TestCaserT r mainTestr" r# r$ r s # ) * ! " 1 > - ..&{&&|4 l ; ;
t||
YY""H- YY""H-
[[($$i0
x));7 YY""H-[[(++[9x)):6
(,,k:
__hnni0
(..)4 \\8$$i0 G
C
, NN) NN- ; * 6 6 &
" LL
> : ,akk , % / G ! 24PQ t'^ t'nm T%% m `nJ.$*>*> nJD
&*"&!% ! # $(, !;?/4,0%*+/!t 09tr 486;BF c@ 7@ c@P (*c #&cLR6RRjn