X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=python%2Fmusicxml.py;h=a7cf59730ff1de9c6886816df7b42abdcb5bfb23;hb=96e14d746b102f223acf6b6f4cdb8b0f0a11cd24;hp=84ffb75080fe7d7165fb60e72a9eb447d967a8df;hpb=c76eb56deebde56cb0add2c4f05e8f1261283d5c;p=lilypond.git

diff --git a/python/musicxml.py b/python/musicxml.py
index 84ffb75080..a7cf59730f 100644
--- a/python/musicxml.py
+++ b/python/musicxml.py
@@ -5,6 +5,13 @@ 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
@@ -14,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 = []
@@ -44,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):
@@ -172,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):
@@ -202,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')
@@ -247,7 +295,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)
@@ -298,19 +346,12 @@ class Note (Measure_element):
 
         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:
-            self.message ("Encountered note at %s without %s duration (no <type> element):" % (self.start, self.duration) )
+            self.message (_ ("Encountered note at %s with %s duration (no <type> element):") % (self.start, self.duration) )
             return 0
 
     def get_factor (self):
@@ -344,7 +385,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):
@@ -439,11 +480,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
@@ -454,6 +495,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 ()
         
@@ -467,7 +509,7 @@ class Part (Music_xml_node):
         measure_position = Rational (0)
         measure_start_moment = now
         is_first_measure = True
-        prvious_measure = None
+        previous_measure = None
 	for m in measures:
             # implicit measures are used for artificial measures, e.g. when
             # a repeat bar line splits a bar into two halves. In this case,
@@ -478,7 +520,7 @@ class Part (Music_xml_node):
             # 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:
+                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:
@@ -493,6 +535,12 @@ class Part (Music_xml_node):
                 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)
@@ -565,12 +613,17 @@ class Part (Music_xml_node):
     # 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 = copy.copy (attr._children)
+        attributes._children = [];
         attributes._dict = attr._dict.copy ()
-        for c in attributes._children:
-            if hasattr (c, 'number') and c.number != staff:
-                attributes._children.remove (c)
-        return attributes
+        # 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 = {}
@@ -614,12 +667,14 @@ class Part (Music_xml_node):
 
 	start_attr = None
         assign_to_next_note = []
+        id = None
 	for n in elements:
 	    voice_id = n.get_maybe_exist_typed_child (get_class ('voice'))
 
 	    if not (voice_id or isinstance (n, Attributes) or
                     isinstance (n, Direction) or isinstance (n, Partial) or
-                    isinstance (n, Barline) or isinstance (n, Harmony) ):
+                    isinstance (n, Barline) or isinstance (n, Harmony) or
+                    isinstance (n, FiguredBass) ):
 		continue
 
 	    if isinstance (n, Attributes) and not start_attr:
@@ -630,8 +685,9 @@ class Part (Music_xml_node):
                 # 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)
-                    for v in vids:
-                        voices[v].add_element (staff_attributes)
+                    if staff_attributes:
+                        for v in vids:
+                            voices[v].add_element (staff_attributes)
                 continue
 
             if isinstance (n, Partial) or isinstance (n, Barline):
@@ -639,22 +695,22 @@ class Part (Music_xml_node):
                     voices[v].add_element (n)
                 continue
 
-            if isinstance (n, Direction) or isinstance (n, Harmony):
-                # store the harmony element until we encounter the next note
-                # and assign it only to that one voice.
+            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)
-                #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 ()
-                ## assign only to first voice, otherwise we'll have duplicates!
-                #if dir_voices:
-                    #voices[dir_voices[0]].add_element (n)
-                ##for v in dir_voices:
-                    ##voices[v].add_element (n)
                 continue
 
 	    id = voice_id.get_text ()
@@ -667,10 +723,17 @@ class Part (Music_xml_node):
                 assign_to_next_note = []
                 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 (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()
@@ -679,6 +742,8 @@ class Part (Music_xml_node):
 
     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):
@@ -689,8 +754,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):
@@ -722,6 +787,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
@@ -741,6 +812,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):
@@ -804,6 +878,48 @@ class Words (Music_xml_node):
 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)
@@ -811,6 +927,7 @@ class Frame (Music_xml_node):
         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)
@@ -825,6 +942,19 @@ class Frame_Note (Music_xml_node):
         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
 ## for every input file. Only add those classes, that are either directly
@@ -836,15 +966,22 @@ class_dict = {
 	'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,
@@ -858,9 +995,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,
@@ -868,6 +1008,7 @@ class_dict = {
 	'time-modification': Time_modification,
         'tuplet': Tuplet,
 	'type': Type,
+	'unpitched': Unpitched,
         'wavy-line': Wavy_line,
         'wedge': Wedge,
         'words': Words,
@@ -894,7 +1035,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()
@@ -908,7 +1050,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
 
@@ -918,14 +1060,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
             
@@ -938,10 +1080,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)