X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=python%2Fmusicxml.py;h=53dd4283d5736e8262800e129eeb86d409f9aac9;hb=8de0c0e819512b7b2cb3a8cf53ce359cc3256110;hp=9788d9745dd9fda26d898660bb13af0634bd168e;hpb=2da532f11f9f472c653995c64cf46e98a46f27e1;p=lilypond.git diff --git a/python/musicxml.py b/python/musicxml.py index 9788d9745d..53dd4283d5 100644 --- a/python/musicxml.py +++ b/python/musicxml.py @@ -1,8 +1,17 @@ +# -*- coding: utf-8 -*- import new import string from rational import * import re import sys +import copy +import lilylib as ly + +_ = ly._ + +def error (str): + ly.stderr_write ((_ ("error: %s") % str) + "\n") + def escape_ly_output_string (input_string): return_string = input_string @@ -12,6 +21,22 @@ def escape_ly_output_string (input_string): return return_string +def musicxml_duration_to_log (dur): + return {'256th': 8, + '128th': 7, + '64th': 6, + '32nd': 5, + '16th': 4, + 'eighth': 3, + 'quarter': 2, + 'half': 1, + 'whole': 0, + 'breve': -1, + 'longa': -2, + 'long': -2}.get (dur, 0) + + + class Xml_node: def __init__ (self): self._children = [] @@ -42,11 +67,11 @@ class Xml_node: return ''.join ([c.get_text () for c in self._children]) def message (self, msg): - sys.stderr.write (msg+'\n') + ly.stderr_write (msg+'\n') p = self while p: - sys.stderr.write (' In: <%s %s>\n' % (p._name, ' '.join (['%s=%s' % item for item in p._attribute_dict.items()]))) + sys.stderr.write (' In: <%s %s>\n' % (p._name, ' '.join (['%s=%s' % item for item in p._attribute_dict.items ()]))) p = p.get_parent () def get_typed_children (self, klass): @@ -87,6 +112,14 @@ class Xml_node: return cn[0] + def get_named_child_value_number (self, name, default): + n = self.get_maybe_exist_named_child (name) + if n: + return string.atoi (n.get_text()) + else: + return default + + class Music_xml_node (Xml_node): def __init__ (self): Xml_node.__init__ (self) @@ -162,6 +195,16 @@ class Identification (Xml_node): return self.get_encoding_information ('encoder') def get_encoding_description (self): return self.get_encoding_information ('encoding-description') + + def get_encoding_software_list (self): + enc = self.get_named_children ('encoding') + software = [] + for e in enc: + softwares = e.get_named_children ('software') + for s in softwares: + software.append (s.get_text ()) + return software + class Duration (Music_xml_node): @@ -192,6 +235,21 @@ class Pitch (Music_xml_node): alter = int (ch.get_text ().strip ()) return alter +class Unpitched (Music_xml_node): + def get_step (self): + ch = self.get_unique_typed_child (get_class (u'display-step')) + step = ch.get_text ().strip () + return step + + def get_octave (self): + ch = self.get_unique_typed_child (get_class (u'display-octave')) + + if ch: + octave = ch.get_text ().strip () + return int (octave) + else: + return None + class Measure_element (Music_xml_node): def get_voice_id (self): voice_id = self.get_maybe_exist_named_child ('voice') @@ -201,15 +259,27 @@ class Measure_element (Music_xml_node): return None def is_first (self): - cn = self._parent.get_typed_children (self.__class__) - cn = [c for c in cn if c.get_voice_id () == self.get_voice_id ()] + # Look at all measure elements (previously we had self.__class__, which + # only looked at objects of the same type! + cn = self._parent.get_typed_children (Measure_element) + # But only look at the correct voice; But include Attributes, too, which + # are not tied to any particular voice + cn = [c for c in cn if (c.get_voice_id () == self.get_voice_id ()) or isinstance (c, Attributes)] return cn[0] == self class Attributes (Measure_element): def __init__ (self): Measure_element.__init__ (self) self._dict = {} + self._original_tag = None + def is_first (self): + cn = self._parent.get_typed_children (self.__class__) + if self._original_tag: + return cn[0] == self._original_tag + else: + return cn[0] == self + def set_attributes_from_previous (self, dict): self._dict.update (dict) @@ -237,7 +307,7 @@ class Attributes (Measure_element): else: return (4, 4) except KeyError: - sys.stderr.write ('error: requested time signature, but time sig unknown\n') + error (_ ("requested time signature, but time sig is unknown")) return (4, 4) # returns clef information in the form ("cleftype", position, octave-shift) @@ -268,7 +338,15 @@ class Attributes (Measure_element): fifths = int (key.get_maybe_exist_named_child ('fifths').get_text ()) return (fifths, mode) - + +class Barline (Measure_element): + pass +class BarStyle (Music_xml_node): + pass +class Partial (Measure_element): + def __init__ (self, partial): + Measure_element.__init__ (self) + self.partial = partial class Note (Measure_element): def __init__ (self): @@ -276,23 +354,16 @@ class Note (Measure_element): self.instrument_name = '' def get_duration_log (self): - ch = self.get_maybe_exist_typed_child (get_class (u'type')) + ch = self.get_maybe_exist_named_child (u'type') if ch: log = ch.get_text ().strip() - return {'256th': 8, - '128th': 7, - '64th': 6, - '32nd': 5, - '16th': 4, - 'eighth': 3, - 'quarter': 2, - 'half': 1, - 'whole': 0, - 'breve': -1, - 'long': -2}.get (log, 0) + return musicxml_duration_to_log (log) + elif self.get_maybe_exist_named_child (u'grace'): + # FIXME: is it ok to default to eight note for grace notes? + return 3 else: - sys.stderr.write ("Encountered note without duration (no element): %s\n" % self) + self.message (_ ("Encountered note at %s with %s duration (no element):") % (self.start, self.duration) ) return 0 def get_factor (self): @@ -326,7 +397,7 @@ class Part_list (Music_xml_node): if instrument_name: return instrument_name else: - sys.stderr.write ("Opps, couldn't find instrument for ID=%s\n" % id) + ly.stderr_write (_ ("Unable to find instrument for ID=%s\n") % id) return "Grand Piano" class Part_group (Music_xml_node): @@ -335,6 +406,11 @@ class Score_part (Music_xml_node): pass class Measure (Music_xml_node): + def __init__ (self): + Music_xml_node.__init__ (self) + self.partial = 0 + def is_implicit (self): + return hasattr (self, 'implicit') and self.implicit == 'yes' def get_notes (self): return self.get_typed_children (get_class (u'note')) @@ -416,11 +492,11 @@ class Musicxml_voice: return self._lyrics - class Part (Music_xml_node): def __init__ (self): Music_xml_node.__init__ (self) - self._voices = [] + self._voices = {} + self._staff_attributes_dict = {} def get_part_list (self): n = self @@ -431,6 +507,7 @@ class Part (Music_xml_node): def interpret (self): """Set durations and starting points.""" + """The starting point of the very first note is 0!""" part_list = self.get_part_list () @@ -441,10 +518,41 @@ class Part (Music_xml_node): measures = self.get_typed_children (Measure) last_moment = Rational (-1) last_measure_position = Rational (-1) + measure_position = Rational (0) + measure_start_moment = now + is_first_measure = True + previous_measure = None for m in measures: - measure_start_moment = now - measure_position = Rational (0) - for n in m.get_all_children (): + # implicit measures are used for artificial measures, e.g. when + # a repeat bar line splits a bar into two halves. In this case, + # don't reset the measure position to 0. They are also used for + # upbeats (initial value of 0 fits these, too). + # Also, don't reset the measure position at the end of the loop, + # but rather when starting the next measure (since only then do we + # know if the next measure is implicit and continues that measure) + if not m.is_implicit (): + # Warn about possibly overfull measures and reset the position + if attributes_object and previous_measure and previous_measure.partial == 0: + length = attributes_object.get_measure_length () + new_now = measure_start_moment + length + if now <> new_now: + problem = 'incomplete' + if now > new_now: + problem = 'overfull' + ## only for verbose operation. + if problem <> 'incomplete' and previous_measure: + previous_measure.message ('%s measure? Expected: %s, Difference: %s' % (problem, now, new_now - now)) + now = new_now + measure_start_moment = now + measure_position = Rational (0) + + for n in m.get_all_children (): + # figured bass has a duration, but applies to the next note + # and should not change the current measure position! + if isinstance (n, FiguredBass): + n._divisions = factor.denominator () + continue + if isinstance (n, Hash_text): continue dur = Rational (0) @@ -503,60 +611,152 @@ class Part (Music_xml_node): if instrument: n.instrument_name = part_list.get_instrument (instrument.id) - if attributes_object: - length = attributes_object.get_measure_length () - new_now = measure_start_moment + length - - if now <> new_now: - problem = 'incomplete' - if now > new_now: - problem = 'overfull' - - ## only for verbose operation. - if problem <> 'incomplete': - m.message ('%s measure? Expected: %s, Difference: %s' % (problem, now, new_now - now)) - - now = new_now + # Incomplete first measures are not padded, but registered as partial + if is_first_measure: + is_first_measure = False + # upbeats are marked as implicit measures + if attributes_object and m.is_implicit (): + length = attributes_object.get_measure_length () + measure_end = measure_start_moment + length + if measure_end <> now: + m.partial = now + previous_measure = m + + # modify attributes so that only those applying to the given staff remain + def extract_attributes_for_staff (part, attr, staff): + attributes = copy.copy (attr) + attributes._children = []; + attributes._dict = attr._dict.copy () + attributes._original_tag = attr + # copy only the relevant children over for the given staff + for c in attr._children: + if (not (hasattr (c, 'number') and (c.number != staff)) and + not (isinstance (c, Hash_text))): + attributes._children.append (c) + if not attributes._children: + return None + else: + return attributes def extract_voices (part): voices = {} measures = part.get_typed_children (Measure) elements = [] for m in measures: + if m.partial > 0: + elements.append (Partial (m.partial)) elements.extend (m.get_all_children ()) + # make sure we know all voices already so that dynamics, clefs, etc. + # can be assigned to the correct voices + voice_to_staff_dict = {} + for n in elements: + voice_id = n.get_maybe_exist_named_child (u'voice') + vid = None + if voice_id: + vid = voice_id.get_text () + + staff_id = n.get_maybe_exist_named_child (u'staff') + sid = None + if staff_id: + sid = staff_id.get_text () + else: + sid = "None" + if vid and not voices.has_key (vid): + voices[vid] = Musicxml_voice() + if vid and sid and not n.get_maybe_exist_typed_child (Grace): + if not voice_to_staff_dict.has_key (vid): + voice_to_staff_dict[vid] = sid + # invert the voice_to_staff_dict into a staff_to_voice_dict (since we + # need to assign staff-assigned objects like clefs, times, etc. to + # all the correct voices. This will never work entirely correct due + # to staff-switches, but that's the best we can do! + staff_to_voice_dict = {} + for (v,s) in voice_to_staff_dict.items (): + if not staff_to_voice_dict.has_key (s): + staff_to_voice_dict[s] = [v] + else: + staff_to_voice_dict[s].append (v) + start_attr = None + assign_to_next_note = [] + id = None for n in elements: voice_id = n.get_maybe_exist_typed_child (get_class ('voice')) - # TODO: If the first element of a voice is a dynamics entry, - # then voice_id is not yet set! Thus it will currently be ignored - if not (voice_id or isinstance (n, Attributes) or isinstance (n, Direction) ): + if not (voice_id or isinstance (n, Attributes) or + isinstance (n, Direction) or isinstance (n, Partial) or + isinstance (n, Barline) or isinstance (n, Harmony) or + isinstance (n, FiguredBass) ): continue if isinstance (n, Attributes) and not start_attr: start_attr = n continue - if isinstance (n, Attributes) or isinstance (n, Direction): - for v in voices.values (): - v.add_element (n) - continue + if isinstance (n, Attributes): + # assign these only to the voices they really belongs to! + for (s, vids) in staff_to_voice_dict.items (): + staff_attributes = part.extract_attributes_for_staff (n, s) + if staff_attributes: + for v in vids: + voices[v].add_element (staff_attributes) + continue + + if isinstance (n, Partial) or isinstance (n, Barline): + for v in voices.keys (): + voices[v].add_element (n) + continue + + if isinstance (n, Direction): + staff_id = n.get_maybe_exist_named_child (u'staff') + if staff_id: + staff_id = staff_id.get_text () + if staff_id: + dir_voices = staff_to_voice_dict.get (staff_id, voices.keys ()) + else: + dir_voices = voices.keys () + for v in dir_voices: + voices[v].add_element (n) + continue + + if isinstance (n, Harmony) or isinstance (n, FiguredBass): + # store the harmony or figured bass element until we encounter + # the next note and assign it only to that one voice. + assign_to_next_note.append (n) + continue id = voice_id.get_text () - if not voices.has_key (id): - voices[id] = Musicxml_voice() + if hasattr (n, 'print-object') and getattr (n, 'print-object') == "no": + #Skip this note. + pass + else: + for i in assign_to_next_note: + voices[id].add_element (i) + assign_to_next_note = [] + voices[id].add_element (n) - voices[id].add_element (n) + # Assign all remaining elements from assign_to_next_note to the voice + # of the previous note: + for i in assign_to_next_note: + voices[id].add_element (i) + assign_to_next_note = [] if start_attr: - for (k,v) in voices.items (): - v.insert (0, start_attr) + for (s, vids) in staff_to_voice_dict.items (): + staff_attributes = part.extract_attributes_for_staff (start_attr, s) + staff_attributes.read_self () + part._staff_attributes_dict[s] = staff_attributes + for v in vids: + voices[v].insert (0, staff_attributes) + voices[v]._elements[0].read_self() - part._voices = voices + part._voices = voices def get_voices (self): return self._voices + def get_staff_attributes (self): + return self._staff_attributes_dict class Notations (Music_xml_node): def get_tie (self): @@ -567,8 +767,8 @@ class Notations (Music_xml_node): else: return None - def get_tuplet (self): - return self.get_maybe_exist_typed_child (Tuplet) + def get_tuplets (self): + return self.get_typed_children (Tuplet) class Time_modification(Music_xml_node): def get_fraction (self): @@ -600,6 +800,12 @@ class Wedge (Music_xml_spanner): class Tuplet (Music_xml_spanner): pass +class Bracket (Music_xml_spanner): + pass + +class Dashes (Music_xml_spanner): + pass + class Slur (Music_xml_spanner): def get_type (self): return self.type @@ -619,6 +825,9 @@ class Pedal (Music_xml_spanner): class Glissando (Music_xml_spanner): pass +class Slide (Music_xml_spanner): + pass + class Octave_shift (Music_xml_spanner): # default is 8 for the octave-shift! def get_size (self): @@ -676,6 +885,88 @@ class Bend (Music_xml_node): else: return 0 +class Words (Music_xml_node): + pass + +class Harmony (Music_xml_node): + pass + +class ChordPitch (Music_xml_node): + def step_class_name (self): + return u'root-step' + def alter_class_name (self): + return u'root-alter' + def get_step (self): + ch = self.get_unique_typed_child (get_class (self.step_class_name ())) + return ch.get_text ().strip () + def get_alteration (self): + ch = self.get_maybe_exist_typed_child (get_class (self.alter_class_name ())) + alter = 0 + if ch: + alter = int (ch.get_text ().strip ()) + return alter + +class Root (ChordPitch): + pass + +class Bass (ChordPitch): + def step_class_name (self): + return u'bass-step' + def alter_class_name (self): + return u'bass-alter' + +class ChordModification (Music_xml_node): + def get_type (self): + ch = self.get_maybe_exist_typed_child (get_class (u'degree-type')) + return {'add': 1, 'alter': 1, 'subtract': -1}.get (ch.get_text ().strip (), 0) + def get_value (self): + ch = self.get_maybe_exist_typed_child (get_class (u'degree-value')) + value = 0 + if ch: + value = int (ch.get_text ().strip ()) + return value + def get_alter (self): + ch = self.get_maybe_exist_typed_child (get_class (u'degree-alter')) + value = 0 + if ch: + value = int (ch.get_text ().strip ()) + return value + + +class Frame (Music_xml_node): + def get_frets (self): + return self.get_named_child_value_number ('frame-frets', 4) + def get_strings (self): + return self.get_named_child_value_number ('frame-strings', 6) + def get_first_fret (self): + return self.get_named_child_value_number ('first-fret', 1) + +class Frame_Note (Music_xml_node): + def get_string (self): + return self.get_named_child_value_number ('string', 1) + def get_fret (self): + return self.get_named_child_value_number ('fret', 0) + def get_fingering (self): + return self.get_named_child_value_number ('fingering', -1) + def get_barre (self): + n = self.get_maybe_exist_named_child ('barre') + if n: + return getattr (n, 'type', '') + else: + return '' + +class FiguredBass (Music_xml_node): + pass + +class BeatUnit (Music_xml_node): + pass + +class BeatUnitDot (Music_xml_node): + pass + +class PerMinute (Music_xml_node): + pass + ## need this, not all classes are instantiated @@ -686,15 +977,27 @@ class_dict = { '#text': Hash_text, 'accidental': Accidental, 'attributes': Attributes, + 'barline': Barline, + 'bar-style': BarStyle, + 'bass': Bass, 'beam' : Beam, + 'beat-unit': BeatUnit, + 'beat-unit-dot': BeatUnitDot, 'bend' : Bend, + 'bracket' : Bracket, 'chord': Chord, + 'dashes' : Dashes, + 'degree' : ChordModification, 'dot': Dot, 'direction': Direction, 'direction-type': DirType, 'duration': Duration, + 'frame': Frame, + 'frame-note': Frame_Note, + 'figured-bass': FiguredBass, 'glissando': Glissando, 'grace': Grace, + 'harmony': Harmony, 'identification': Identification, 'lyric': Lyric, 'measure': Measure, @@ -705,9 +1008,12 @@ class_dict = { 'part-group': Part_group, 'part-list': Part_list, 'pedal': Pedal, + 'per-minute': PerMinute, 'pitch': Pitch, 'rest': Rest, - 'score-part': Score_part, + 'root': Root, + 'score-part': Score_part, + 'slide': Slide, 'slur': Slur, 'staff': Staff, 'syllabic': Syllabic, @@ -715,8 +1021,10 @@ class_dict = { 'time-modification': Time_modification, 'tuplet': Tuplet, 'type': Type, + 'unpitched': Unpitched, 'wavy-line': Wavy_line, 'wedge': Wedge, + 'words': Words, 'work': Work, } @@ -740,7 +1048,8 @@ def get_class (name): def lxml_demarshal_node (node): name = node.tag - if name is None: + # Ignore comment nodes, which are also returned by the etree parser! + if name is None or node.__class__.__name__ == "_Comment": return None klass = get_class (name) py_node = klass() @@ -754,7 +1063,7 @@ def lxml_demarshal_node (node): for c in py_node._children: c._parent = py_node - for (k,v) in node.items (): + for (k, v) in node.items (): py_node.__dict__[k] = v py_node._attribute_dict[k] = v @@ -764,14 +1073,14 @@ def minidom_demarshal_node (node): name = node.nodeName klass = get_class (name) - py_node = klass() + py_node = klass () py_node._name = name py_node._children = [minidom_demarshal_node (cn) for cn in node.childNodes] for c in py_node._children: c._parent = py_node if node.attributes: - for (nm, value) in node.attributes.items(): + for (nm, value) in node.attributes.items (): py_node.__dict__[nm] = value py_node._attribute_dict[nm] = value @@ -784,10 +1093,10 @@ def minidom_demarshal_node (node): if __name__ == '__main__': - import lxml.etree + import lxml.etree - tree = lxml.etree.parse ('beethoven.xml') - mxl_tree = lxml_demarshal_node (tree.getroot ()) - ks = class_dict.keys() - ks.sort() - print '\n'.join (ks) + tree = lxml.etree.parse ('beethoven.xml') + mxl_tree = lxml_demarshal_node (tree.getroot ()) + ks = class_dict.keys () + ks.sort () + print '\n'.join (ks)