jgt 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 j' Z' ej( d Z) G d d ej* Z+ G d d ej, Z-d Z.d Z/d Z0d!Z1d"Z2dZ3d#Z4d$Z5d%Z6d&Z7d Z8ej9 e-j: e.fej; e-j: e/fej< e-j: e0fej= e-j: e1fej> e-j: e2fe j? e-j@ e3fejA e-jB e4fejC e-jB e5fejD e-jE e6fejF e-jG e7fejH e-jI e8fg ZJd'eKd(< e-jB d)e-jE d*e-jG d+e-jL d,e-jI d-e-j: d.e-jM d/e-j@ d0iZNd1eKd2< ejO ejP ejQ ejR gZSd3eKd4< G d5 d6e jT 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` ZaddEdddFddGdEddEddGdEdGdEdHd`dKZbdEdGddLd`dMZcddFdNdadQZddbdUZedV ZfdcdYZgdZ Zhddd[Zided\Zj G d] d^e
jk Zlemd_k rddl Z e jn el dS dS )fa
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 ZdS )BrailleSegmentExceptionN)__name__
__module__ __qualname__ /Users/tedpeters/Documents/Projects/Claude Projects/Misc Tools/notename-sheets/.venv/lib/python3.11/site-packages/music21/braille/segment.pyr r : s Dr# r c 2 e Zd ZdZdZdZdZdZdZdZ dZ
d Z d
S ) Affinity
N) r r r! _LOWEST SIGNATURETTEXTMMARK
LONG_TEXTEXPRINACCORDSPLIT1_NOTEGROUP NOTEGROUPSPLIT2_NOTEGROUPr" r# r$ r& r& > s? 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< dS )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< dS dS )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 sT
'/+.+;A+>+> ((0,1,?,F,F ))) 10r# 0 _ThreeDigitNumber)hundredstensonesc H e Zd ZU dZded< dZded< dZded< dZded < dS )
SegmentKeyr intmeasureordinalNzAffinity | Noneaffinityz
str | Nonehand)r r r! rQ rB rR rS rT r" r# r$ rO rO sV GG "H""""Dr# rO c b e Zd ZU dZdddddddZd ed
< d Zd Zd
Zd Z d Z
d Z ddZ d Z
dS )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| _
d S )Nr@ rA TFr ) list internalListrH rC r@ rA rW rX upperFirstInNoteFingeringrY rZ )self listElementss r$ __init__z BrailleElementGrouping.__init__ s_ , / ,^ < -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 |< d S 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 V |dk rt d t | j | S )Nr_ z internalList not defined yet)AttributeErrorgetattrr_ )ra attrs r$ __getattr__z"BrailleElementGrouping.__getattr__ s/ > ! ! !?@@ @t($///r# returnstrc N g }d}| D ]*}t |t j r|r(| dt j d |D ]n} | d |j j 6# t t f$ r% | t | Y kw xY wd} | d |j j n9# t t f$ r% | t | Y nw xY wd},| j dk r!| d| j dz d | j
du r(| d
t j d d | }|S ) 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 TypeErrorr{ rZ rY )ra
allObjectsprevious_was_voiceobjobj2outs r$ __str__z BrailleElementGrouping.__str__ s
#( + +C#v|,,
+% Z %%&Xv~o7V&X&XYYY 5 5D5"))$))DN4Q*R*RSSSS *I6 5 5 5"))#d))444445%)""0 %%dii
0L&M&MNNNN& 2 0 0 0 %%c#hh/////0%*"" ?Q Gt/B G G G H H H ?d " " Nfn^.L N N O O Oii
##
s$ 2B3B<;B<2C663D,+D,c * t | j S re )reprr_ rg s r$
_reprInternalz$BrailleElementGrouping._reprInternal ri r# N)rz r{ )r r r! __doc__r\ rB rc rh rn rq rt ry r r r" r# r$ rV rV s ( (T ^a ?8
MF
!
!I
' ' '' ' '& & && & &0 0 0
<' ' ' ' 'r# rV c
e Zd ZU ddddddddd d
Zd ed < d1d2 fd
Zd Zd Zd Zd Z d Z
d Z d Z e
d Zd Zd Zd Zd Zd Zd Zd3d!Zd" Zd4d%Zd5d'Z d6d)Zd3d*Zd+ Zd, Z d- Z d. Z d/ Z d0 Z xZ!S )7BrailleSegmentzIf 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\ ( r rP c D t | i | _ t | _ d| _ d| _ d| _ d| _ d| _ d| _
d| _ d| _ d| _
d| _ d| _ d| _ d| _ d| _ dS )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 |< d S re r )ra rm values r$ rq zBrailleSegment.__setitem__~ s #(4 r# c Z || j vrt | j |< | j | S re )r rV rl s r$ rn zBrailleSegment.__getitem__ s1 t) ) )'='?'?D t $!$''r# c N || j vr
| j |= d S t d|d S )NzNo item z in Segment)__dict__r
ValueErrorrl s r$ __delitem__zBrailleSegment.__delitem__ s: t} $ $"4((( < < < <== =r# c , t | j | S re )rw r rl s r$ ry zBrailleSegment.__getattr__ s t)4000r# 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 | S )z@
Returns the string from the BrailleText object
)r BrailleTextr rg s r$ brailleTextzBrailleSegment.brailleText s
''---r# c
$ d}t | }g }g }t }|D ]\ }} |j t j k r|} n# t $ r Y nw xY w| d|j dt |j d|j
dz d t | }| | |}d d t || D } d d || d
g }
|
S ) Nz(Measure z, r9 :
r~ c 3 * K | ]\ }}| | d V dS )z
===Nr" ).0kgs r$ z)BrailleSegment.__str__.. sD (
(
1 N!NNN(
(
(
(
(
(
r# 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__ so 9$**,,'' ,,#+ Wh
#x'@@@ %G A
NN,7? , , !12, ,?Q&, , ,
x==D % % % GG "ii (
(
G\22(
(
(
ii. ,,. / /
s A
A$#A$c t t | | _ | j r| | j r| | j | d| _
| j r| j | _ | j j
}|t j k r| n|t j k r| nn|t j k r| nI|t j k r| n$|t j k r| | j | _
| j | j 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&J&JD # # 6 ? 8#555((****!X%777--////!X%;;;224444!X%666,,....!X^33--///'+'>D $ ( ?" r# c n |D ]1}t j D ]"}t || rt || #2dS )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 sR
$ $B0
$
$2r?? $BOOO
$ $ $r# c | j t j d z g}| d | dS )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 sA *V\'-BBC
277:../////r# c | j p-t t | }|d }|j }t j | }| j r|t d z
}| | dS )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 s 4 (FE&2E2E,F,F a& + 3 -.?@@
, WU^ +M m,,,,,r# c d}d}d}d}| j p-t t | }|r|d j t
j k rn| }|j }| j | }|t
j
k r_t | dk r|d |d }}nlt | dk r'|d } t | t j r| }n4| }n1|t
j k r |d }n|t
j k r|d }|t! ||||g r5t# j ||||| j }
| |
dS dS )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) s
!% : XeF499;;DWDW>X>X # :$Q'08>AA'//11C "| %)%7%;%;C%@%@ " 8#555-..!333I!3L3I!3L #0LL/00A55#9!#? $(
"+ ,di88
. 0&,??
b !!%7"`"`"`aaa12DEEL
! ##Ay111 ,5,FL ))2)@L &5>5XL 2:D Lgo 6 6"O u ;L I I IO _ - - - JJ! r# c | j }| j | }|d }t j | }| | dS )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 s[
%!%!3!7!7!>> 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 Fc F g | ] }t |t j | S r" r r Noter ns r$
zDBrailleSegment.showLeadingOctaveFromNoteGrouping.. s) HHH!z!TY/G/GHAHHHr# Tr r' ) r r rS r& r7 rQ rR rT r r r showOctaveWithNote)ra r
currentKey previousKeyallNotesshowLeadingOctave firstNotes r$ !showLeadingOctaveFromNoteGroupingz0BrailleSegment.showLeadingOctaveFromNoteGrouping} s B ,
.
# *$(::: &(*<<< &+*==="*k.AA.EEE";+;;; $
# 5 IH|HHH )}( $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 sN & !Oq 0Od&6&CC ) ) )+,,/@@@45r# Fc t j }d}d}d\ }}d} ||k rZt || \ }}||_ d|_ | | } | j | | rn|dz
}`| j }
|
|_ | | } | j } |
t 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 s2 355 -9* / # #3331B #52 2 2 ._o -EK ))-O &#.#>#>#O#O ))*> )YY
! # $ 8 8(9 % * : :? K K ,
""H,E"FF""H,E"FF$T
$T
$&:;;r# c v t j }| j t d | j | j }| | }||_ | | }| | }| j
|| r | j || n| | }|r_ |
||| \ }}| j || | | n# t $ r d}Y nw xY w|sW|du r%| j du r d|_ | | }| j | | | |j | | dS )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% r; addToNewLiner r lastHyphenToSpaceaddRepeatSymbolsrZ r ) ra r3 r r r" r* should_splitbngAbngBs r$ r z"BrailleSegment.extractNoteGrouping% s 355 " * ^__ _)$*AB B B< P P(9 % ) 9 9, G G99:MNN % %&9H % M M ! 7 # #$7( # K K K K!%!5!56I!J!JL
)
)!%!D!D\ARAI"K "KJD$ $++D8+DDD%%d++++. ) ) ) $)LLL)
7 %--$2Je2S2S 59K1*5*E*El*S*S' 22444!!"5666 l 5666 -----s A D D.-D.c d|cxk rdk r7n n4t | D ]"}| t d #dS |dk r>| t d t j | z d| _ dS dS )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$ r@ z BrailleSegment.addRepeatSymbolsZ s 0
{ Q (-k(:(:
6
6$""78#45555
6
6
A
wx 053H3U3U U V V V DMMM
r# c d}d}| j }| j | }t | dk r|d |d }}nWt | dk rD| j | j d }t |t
j r|}n|}d}| j r| |j }n# t $ r Y nw xY wt j ||| }|dk r| | dS dS )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 rJ
brailleSigs r$ r z'BrailleSegment.extractSignatureGroupingz s+
%)--c22 | ! !*6q/<?-LL
!
#
# -11$2IJJ1ML,(899
- + ,
$ )A
!-!<!
/ m^\\
z * * * * * s -B5 5
CCc | j | j | j j t
j k r | j | j | | dS )z9
Extracts a tempo text and processes it.
N) r
appendleftr r rS r& r1 r r rg s r$ r z'BrailleSegment.extractTempoTextGrouping sv
"--d.EFFF # ,0B B B & 1 1$2J K K K !!#####r# c t | j }d}t | D ]F\ }}|j t
j k r|||< d}"||}|D ] }|| | G|S )ag
Puts together certain types of elements according to the last digit of their key
(if it is the same as Affinity.NOTEGROUP or not.
>>> 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 $DO44
+1$**,,+?+? 4 4 '[,#x'999*6
;' > (F ( 4 4D v&--d33334r# c B t j d }t j d }t | }d\ }}|D ]<\ }}||j dk rd|_ |j dk r|j t j
k r|j dk rt|j t j
k r_t |d t j
rt |dd | }nt || }|r|xj dz
c_ | |= |j t j k rF|D ]B} t | t j r| } t | t j r || _ | }Cn|j t j t j
fv rt |d t j
rgt |d t j t j f rd| _ n3t |d t j t j f rd| _ d |D }
t1 |
dk r-t |
d t2 j r
d|
d _ ||_ ||_ | j |_ | j |_ | j |_ ||}}>| j r d|_ dS dS ) 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 TFc F g | ] }t |t j | S r" )r r GeneralNoter s r$ r z8BrailleSegment.addGroupingAttributes.. s* "^"^"^jDL\>]>]"^1"^"^"^r# )!r rF r rG r r rR rY rS r& r7 r r r areGroupingsIdenticalrZ r1 rJ r5
TrebleClefAltoClefrW BassClef TenorClefrs r Rest fullMeasurer@ rA rX r` r ) ra
currentKeySigcurrentTimeSigr r previousListrR rS isRepetitionbrailleElementallGeneralNotess r$ addGroupingAttributesz$BrailleSegment.addGroupingAttributes s (++
,U33 djjll++ &2#l+7 ' F ' F '[,& &!++.2L+ '1,, ' 0H4F F F ' /1 4 4 ' 0H4F F F!,q/49== Y'<\!""=M|'\'\ '<\<'X'X # !$//14// - #x'999&2 7 7N!.%2EFF 7)7#NC4DEE 78E5(6
7 %(*;X=O)PPP l1oty99 6!,q/DOT]3STT 604--#LOdmT^5TUU 605- #_"^l"^"^"^''1,,OA +&*L # # # + +r# c | ddl m fd}| fd D }|D ]w}d |D }t t | D ]L}|| }|j D ]:}t
|j rt
|j r ||||| ;MxdS )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 | j }t | j j f rV|j O|j j dk r!d ||dz
_ d||dz
_ nd ||dz _ d|_ d |_ d}t |dz t | D ]#}|| }|d |j D v r|dz
}# |dk rd S |j
| t |dz ||z D ]9}|| }|j D ]'}|j |k r|j | (:d S )Nstopr9 Tr c g | ] }|j
S r" )r )r as r$ r zOBrailleSegment.fixArticulations..fixOneArticulation.." s S S SA S S Sr# r( ) r r StaccatoTenutotietype shortSlurrF rs rg r remove)
articmusic21NoteStartr noteIndexStart articName
numSequentialnoteIndexContinuemusic21NoteContinueartOtherrg s
r$ fixOneArticulationz;BrailleSegment.fixArticulations..fixOneArticulation s
I5=#9=;O"PQQ
,(,8#',667;H^a /04=AH^a /0::7;H^a /0415$.'+ $ M%*>A+=s8}}%M%M
!&./@&A# S S1D1R S S SSS!Q&M q
* 1 1% 8 8 8%*>A+=+9M+I&K &K
K
K!&./@&A# 3 A K KH } 11+9@@JJJK
K
Kr# c J g | ] }|j t j k | S r" )rS r& r7 )r gpKeyrP s r$ r z3BrailleSegment.fixArticulations..3 s; I I I!&#(>X5G#G#G $E*#G#G#Gr# c F g | ] }t |t j | S r" r r s r$ r z3BrailleSegment.fixArticulations..7 s) R R RAAty9Q9Q Ra R R Rr# N) music21rg rT r rF rs r TechnicalIndicationBowing)
ra rz
noteGroupingsr allNotes_outernoteIndexStart_outermusic21NoteStart_outer artic_outerrg rP s
@@r$ fixArticulationsz BrailleSegment.fixArticulations sD " *))))) K K K K K< %%''
I I I I*4//*;*;I I I
* L R R R R RN(-c..A.A(B(B
$)78L)M #G K &{M4U V V )+}7K L L** ' 2 * 0
r# r r rP )rz r )r rV )rz r )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% r; r r@ r r rT re r
__classcell__)r s @r$ r r sh !U ZF#SB2 -?
> > 1 1 1* * *( ( (' ' ' . . X. D( ( ( T$ $ $0 0 0"!- !- !-F-, -, -,` 2 2 2 2^! ^! ^! ^!@ : AF7<+< +< +< +$ $ $% % %N5+ 5+ 5+nA A A A A A Ar# r c P e Zd ZdZd
ddZed Zd Zd Zd Z d
Z
d Z d S )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
r r rP c t | | t j | | t | _ d | _ d | _ d S )Nr )r rc r BrailleKeyboardr allKeyPairspreviousGroupingPaircurrentGroupingPair)ra r s r$ rc z BrailleGrandSegment.__init__N s\ <<< %%dz%BBB:?''
$(!#' r# c @ t j | S re )r r r rg s r$ r z BrailleGrandSegment.brailleTextV s #++D111r# c d}g }| D ] \ }}|hd|j dt |j d|j dz d}t | j | }d ||g }nd}|hd|j d t |j d|j dz d}t | j | } d || g }
nd}
| d
||
d g d
d |d | 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 s C#'#A#A#C#C H H Xw#1x / 1 1$X%671 1 '!+1 1 1
!$D$6$:$:8$D$D E E
GG\=$A B B "0 0 0$W%560 0 *0 0 0
#4#5#9#9'#B#B C C 77K #>?? OODIIy(H&E F F G G G Gii4 **24 5 5
r# c # K d }d }d}d}t | | D ]}|j dk ri|d ||| r||fV nN|j t j k r1 || t j | r||fV nd|fV |}d}s|}v|j dk rD|@ ||| r||fV n*|j t j k r
|dfV d|fV n|dfV |}d}|}|r|dfV |rd|fV dS dS )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 L | 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 s6 ')) &
(:J.matchOther s? %)999%-1AAA%.(2CCCt ur# Nr r r+ left)r r rT rS r& r7 r0 r5 )ra r r storedRight
storedLeftthisKeys r$ r z-BrailleGrandSegment.yieldCombinedGroupingKeysy s > V V V
diikk/@AAA ) )G|w&& )!z':66 . &
33333!*h.@@@ (j)9)98CT)9)U)UWa b b A '
33333 #Z 0000&- !%JJ")KK '' *!z';77 - *G 44444$-0AAA *D 1111 #Wo---- *D 1111%,
"&KK!(J & % % % % %$ $ $ $ $ $ % %r# c : t | | _ | j d }|d r
|d j n |d j }t t | | _ | d| _ | j r}| j | _ | j
| _ | j \ }}||j t j
k s|)|j t j
k r| | j }| 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 !!?!?!A!ABB#B'08 T!,,!AT*-c..A.A*B*B' #' +(,(@D %'+'7'?'?'A'AD $"&": Xw%(*;x?P*P*P +0@HDU0U0U((*** + r# c d}d}d}d}| j rI| j d \ }}|} | j | }nG# t $ r:} | j d dk r | j | }|}n| Y d} ~ nd} ~ ww xY w|j t j k rn| j |j t j k rM |d |d }}nv# t $ r. t |t j
r |d }n|d }Y n?w xY w|j t j k r |d }n |j t j k r|d }| j I t j ||||| j }
| |
dS # t j $ r } | j d dk r| Y d} ~ dS d} ~ 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"
."&"21"5 Xw F
! / 3 3H = =
71:''!%!3!7!7!@!@J $FF H FFFF
// $ $ & & &("44462?? 6'1!} (21
6
HN22 &qM HN22 *1
3 .6 " 4 "o N
OON + + + + +* x{ 777 877777 s? ?
B 0A>>B C 5DD3F F= F88F=c j \ }}|r|j }n|r|j }nt d t j |d } fd} || } || } ||| d S )Nz/Measure must be defined for leftKey or rightKeyF)withNumberSignc ^ | | j t j k r̉j | }g }|D ]}t |t j s t | }|j |_ |j
|_
|j |_ | t j | | t d | }nH| Dj | }t j | } | nd}|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.EIZ.Z.Z . 2 2> B B $- : :L%lFLAA ! #9,#G#GL4=4NL11:1HL.=F=`L: &&u'CL'Q'QRRR++L9999 $_ 5 : :; G G
+ # 1 5 5n E E " 9, G G
'' 5555
r# )r rQ r r r addNoteGroupings)ra r r mNumcurrentMeasureNumberr rhBraille lhBrailles ` r$ r z'BrailleGrandSegment.extractNoteGroupingM s " 67 P#DD
P?DD NOO O $ 4T% P P P 0 #N8,, "N7++ 2IyIIIIIr# Nr r ) r r r! r rc r r r r r r r r" r# r$ r r E s ( ( ( ( ( 2 2 X2 >T% T% T%J :0 0 0d&J &J &J &J &Jr# r Tr F)setHandr rW r r
segmentBreaksrX r r r showLongSlursAndTiesTogether showShortSlursAndTiesTogetherslurLongPhraseWithBracketsr r` r bool | Nonec ( t | | | |
t | || }|D ]i}||_ ||_ ||_ | ||_ ||_ ||_ | |_ |
|_
||_ | j|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 re 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 sdS ||}| j }| j t
j D ]}| }| } | | }| | } n# t j $ r Y hw xY wt | |z
dz }
|s[|
t k rP|| j || j j dk r|dz
}|| j || j j dk r| dz } |s[|
t k rP|| j || j j dk r|dz
}|| j || j j dk r| dz } |
t k r"t! || D ]} d|| _ h|r d|| _ d|| _ d||dz _ d|| dz
_ dS )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 startri T)
spannerBundleflattennotesr
getByClassr SlurgetFirstgetLastindexr StreamExceptionabs SEGMENT_MAXNOTESFORSHORTSLURrn ro rF rp beginLongBracketSlurendLongBracketSlurbeginLongDoubleSlurendLongDoubleSlur) r r r r r slurr r
beginIndexendIndexdelta noteIndexs r$ r r < sV j $ #+'A$""$$*1133H)44W\BB (@ (@MMOO <<>> ! 22J ~~h//HH+
H Hz)**Q., :V1V1V $(4 ,05@@a
!%1hx6H6L6QU[6[6[A
+ 8T0T0T$(4 ,05@@a
!%1hx6H6L6QU[6[6[A
0 0 0 ":x 8 8
5
5 04#--
5 *
@<@$98<"55?Ca (<;?A &88Q(@ (@s *B44CCr r rP c g }t | }d}d}| t j D ]}t | t | }d} t j }
|D ]p} |r`| j dk rd|_ |
| t | }| j dk rd|_ d}|
t j ur| dz
} d}d| j v r d| j v r |t k rn|dk rd}t | t j r|t k r | j d v rd}| j j |
k r| dz
} | j j } | t j k r
t j } n | t j k r t j } t1 |j | | | }
|
|vrt5 ||
< ||
}|
| |dz
}| j j }
r|
| |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 Barlinero r affinityCoder6 r5 r8 r7 rO numberrV )r r r r currentSegmentelementsInCurrentSegmentstartANewSegmentmusic21MeasurebrailleElementsrR previousAffinityCoderc r r brailleElementGroupings r$ r r sg p K#}===N$% "%88 HH AI AI>***0 @@ ' / - ; I ; IN
)!(C// 04N, "">222!/=!I!I!I!(C//6:N3+,('x/???qLG#( '>+AAA48NNN 48O O O-11'+$>3;77
(,/FFF"'+>>> $( '47KKK1 )3@Lx 888 ' 0 !::: ' 1 #N$9$+$0$+& &J
//-C-E-Ez*%3J%? " " ) ). 9 9 9 $ ) $ $2#;#H w; Ix ~&&& r# music21MeasureOrVoice stream.Measure | stream.Voicerz c t }d}| D ]Xt t j r} t t j r j dk rGt ||t t j t j f rVt | j j
|j _
t | g|j _ | | d}| t gj _ # t" $ rH}fdt$ D }t' | st( | Y d}~Rd}~ww xY w| d t/ | dk rdt |d t0 j rDt |d t j r$d|d _ | d |S )
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 0 g | ]}t | S r" )r )r music21Class
music21Objects r$ r z*extractBrailleElements.. s9 H H H ( #=,?? H H Hr# c | j | j fS re r classSortOrderxs r$ z(extractBrailleElements.. s AHa.>#? r# r r: r' c | j | j fS re r r
s r$ r z(extractBrailleElements.. s AHa6F+G r# )rV r r r r r ro setAffinityCoder rW r r r r r{ r r r r= r r r sortrs r
Dynamicr )r allElementsr notSupportedExceptionisExemptr s @r$ r r s X )**K $I. > >
mTY / / %I >-55
%22 M * * *$!D$4fl#C*E *E$ ***3@3J3W #069)nn5E #2""9--- } - - -69-6H6H5IM # 2 2& > > >H H H H,FH H HHx==
> !!%:"<=== > ??@@@
;1 KOX=M!N!N k"os{ 3 3 I-/KO * !G!G H H H s %DB>> 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 D | j d uot | j dk S )Nr )beamsrs r unuseds r$ withBeamFilterz*prepareBeamedNotes..withBeamFilterI s! $;#bh--!*;;r# c H | j d j dk S )Nr9 r r getByNumberro r s r$ beamStartFilterz+prepareBeamedNotes..beamStartFilterL s x##A&&+w66r# c H | j d j dk S )Nr9 ri r r s r$ beamStopFilterz*prepareBeamedNotes..beamStopFilterO s x##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 rF r r r] rP beatr )r r
sampleNoteallNotesAndRestsr r r allStartIter allStopIter beamIndex startNotestopNote
startIndex stopIndexr allNotesOfSameValuer
afterStopNotebeforeStartNotes r$ r r sx J #**,,H ( (
$
"'
%3::<<< < <7 7 76 6 6 ==??,,^<<FFWWL--//++N;;EEnUUK
<C , ,,,`aaa ), 7 7 2< 2< 9 "c ) ) y)%++I66
$**844 J&* 199 # zA~y1}== I +9Y=TTT!"29"=tyII U&+# U ,Y] ;M=$)44
, ] /00C
4F4FFF&+# D " A
.<CC D D # .zA~ >O?DI66
.O 011S 5H5HHH'59PPP)- & D zA~y1}== < >> 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\ 2 2 37M # 0+4M ( FF
-!;<< /7/A
, }$**,, - - 1 13;3IM # 0'(
$-!;<<
!]"V"V"V
W
WWr# c t | t | k r!t | | D ]\ }}||k r dS dS dS )a3
Takes in two note groupings, noteGroupingA and noteGroupingB. Returns True
if both groupings have identical contents. False otherwise.
Helper for numRepeats.
Needs two identical length groupings.
>>> 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$ rX rX s^ * =S / ///$'
}$E$E Xx8## uu $t 5r# c v t j }| D ] }| |j | t ||| j \ }}t
j | }g |_ |D ]}| | t
j | }g |_ |D ]}| | ||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 rc leftMeasure rightMeasureleftBrailleElementsrightBrailleElementss r$ r- r- s H ^%%N& E E n 3^DDDD".~/A/;/I#K #K [, )L11')$% 3 3"">2222 9\22(*%& 4 4 ##N3333 4 44r# c ||}n| }d}|dk rt | t |j k rt d| d|j t |j t | z
} |t |j | j z
}t | }n3# t $ r& t d| j
d Y nw xY wt j |j
}d} | |d
| d \ }} nq# t j $ r_ |d z
}| |d
| d d }| d d
} Y nw xY w| |z } t% j }
t% j } | D ]t} | j |k rL| j | k s%| j | k r6t+ | t, j r |
| j | Y| | j | u| j D ]C}
|
j :|
|
| |
| |
j j z
} C | j j | z
}t= j | }|
| | t= j | }| d| d }|
j d}||
_ || _ |
! | | ! | |
" d | " d tG |
tG | |
| | | |r|
| | | |
| fS )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}
Nr 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 rB deepcopy beatSequencepartitionByCount getLevelSpanr MeterExceptionr r r r r r r r rn r rq durationr r] rA mergeAttributes makeBeamsr )r r( useTimeSignaturetsr duration_indexbsnumberOfPartitionsstartOffsetZero
endOffsetZerorC rD r r rest0Lengthr0r1
ts0_deletes r$ rA rA s_ , #
-
-
/
/
FQ ! " "S)A%B%B B B)J&8 J J/1/GJ J
R 566=O9P9PP O fR 5n E STT TFF^^FF O O O N!/!6 N N N
O
O
O
O
O O
r ' 'B2
.EBBB+-??+<+##L
- -
H ' 'X
--]22 '3; 7 7 3 qx + + + + ! , , , ,
5 q ! ! ! " " " QZ 5 5M
)7-GK
- - -B}b)))
/ / /BR J (
$& !!#L /// 000$'''4((({###|$$$r 2 &&s% 1B8 8-C('C(4D< r s # " " " " " ) ) ) ) ) ) ) ) * * * * * * ! ! ! ! ! ! " " " " " " 1 1 1 1 1 1 > > > > > > - - - - - - .&{&|44 l ;
t|
Y"H- Y"H-
[($i0
x);7 Y"H-[(+[9x):6
(,k:
_hni0
(.)4 \8$i0 G
, N) N- ; * 6 6 &
L
> , , , , ,ak , , , % % G G G ! J 24P4P4PQQ t' t' t' t' t'^ t' t' t'nm m m m m T% m m m `nJ nJ nJ nJ nJ.$*> nJ nJ nJD
&*"&!% ! # $(, !;?/4,0%*+/!t t t t t tr 486;BF c@ c@ c@ c@ c@ c@P (*c c c c c cLR R R Rjn< n< n