X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=python%2Fmusicxml.py;h=53dd4283d5736e8262800e129eeb86d409f9aac9;hb=8de0c0e819512b7b2cb3a8cf53ce359cc3256110;hp=7281a129f3921a49c95bc860dde67acf8b8ecd6f;hpb=8dbe802ee040d1f5fd9cc439081194d41ef4dbf2;p=lilypond.git

diff --git a/python/musicxml.py b/python/musicxml.py
index 7281a129f3..53dd4283d5 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):
@@ -89,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)
@@ -164,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):
@@ -194,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')
@@ -203,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)
         
@@ -239,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)
@@ -270,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):
@@ -278,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 <type> element): %s\n" % self)
+            self.message (_ ("Encountered note at %s with %s duration (no <type> element):") % (self.start, self.duration) )
             return 0
 
     def get_factor (self):
@@ -328,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):
@@ -337,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'))
 
@@ -418,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
@@ -433,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 ()
         
@@ -443,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)
@@ -505,36 +611,40 @@ 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 = 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
+        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
@@ -549,6 +659,8 @@ class Part (Music_xml_node):
             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):
@@ -567,12 +679,15 @@ 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'))
 
-            # 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:
@@ -583,8 +698,14 @@ 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):
+                for v in voices.keys ():
+                    voices[v].add_element (n)
                 continue
 
             if isinstance (n, Direction):
@@ -592,20 +713,40 @@ class Part (Music_xml_node):
                 if staff_id:
                     staff_id = staff_id.get_text ()
                 if staff_id:
-                    dir_voices = staff_to_voice_dict[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 ()
-	    voices[id].add_element (n)
+            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)
+
+        # 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()
@@ -614,6 +755,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):
@@ -624,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):
@@ -657,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
@@ -676,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):
@@ -733,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
@@ -743,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,
@@ -762,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,
@@ -772,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,
 }
 
@@ -797,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()
@@ -811,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
 
@@ -821,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
             
@@ -841,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)