python/musicexp.py

   1 import inspect
   2 import sys
   3 import string
   4 import re
   5
   6 from rational import Rational
   7
   8 class Output_stack_element:
   9     def __init__ (self):
  10         self.factor = Rational (1)
  11     def copy (self):
  12         o = Output_stack_element()
  13         o.factor = self.factor
  14         return o
  15
  16 class Output_printer:
  17
  18     """A class that takes care of formatting (eg.: indenting) a
  19     Music expression as a .ly file.
  20
  21     """
  22     ## TODO: support for \relative.
  23
  24     def __init__ (self):
  25         self._line = ''
  26         self._indent = 4
  27         self._nesting = 0
  28         self._file = sys.stdout
  29         self._line_len = 72
  30         self._output_state_stack = [Output_stack_element()]
  31         self._skipspace = False
  32         self._last_duration = None
  33
  34     def set_file (self, file):
  35         self._file = file
  36
  37     def dump_version (self):
  38         self.newline ()
  39         self.print_verbatim ('\\version "@TOPLEVEL_VERSION@"')
  40         self.newline ()
  41
  42     def get_indent (self):
  43         return self._nesting * self._indent
  44
  45     def override (self):
  46         last = self._output_state_stack[-1]
  47         self._output_state_stack.append (last.copy())
  48
  49     def add_factor (self, factor):
  50         self.override()
  51         self._output_state_stack[-1].factor *=  factor
  52
  53     def revert (self):
  54         del self._output_state_stack[-1]
  55         if not self._output_state_stack:
  56             raise 'empty'
  57
  58     def duration_factor (self):
  59         return self._output_state_stack[-1].factor
  60
  61     def print_verbatim (self, str):
  62         self._line += str
  63
  64     def unformatted_output (self, str):
  65         self._nesting += str.count ('<') + str.count ('{')
  66         self._nesting -= str.count ('>') + str.count ('}')
  67         self.print_verbatim (str)
  68
  69     def print_duration_string (self, str):
  70         if self._last_duration == str:
  71             return
  72
  73         self.unformatted_output (str)
  74
  75     def add_word (self, str):
  76         if (len (str) + 1 + len (self._line) > self._line_len):
  77             self.newline()
  78             self._skipspace = True
  79
  80         if not self._skipspace:
  81             self._line += ' '
  82         self.unformatted_output (str)
  83         self._skipspace = False
  84
  85     def newline (self):
  86         self._file.write (self._line + '\n')
  87         self._line = ' ' * self._indent * self._nesting
  88         self._skipspace = True
  89
  90     def skipspace (self):
  91         self._skipspace = True
  92
  93     def __call__(self, arg):
  94         self.dump (arg)
  95
  96     def dump (self, str):
  97         if self._skipspace:
  98             self._skipspace = False
  99             self.unformatted_output (str)
 100         else:
 101             words = string.split (str)
 102             for w in words:
 103                 self.add_word (w)
 104
 105
 106     def close (self):
 107         self.newline ()
 108         self._file.close ()
 109         self._file = None
 110
 111
 112 class Duration:
 113     def __init__ (self):
 114         self.duration_log = 0
 115         self.dots = 0
 116         self.factor = Rational (1)
 117
 118     def lisp_expression (self):
 119         return '(ly:make-duration %d %d %d %d)' % (self.duration_log,
 120                              self.dots,
 121                              self.factor.numerator (),
 122                              self.factor.denominator ())
 123
 124
 125     def ly_expression (self, factor = None):
 126         if not factor:
 127             factor = self.factor
 128
 129         str = '%d%s' % (1 << self.duration_log, '.'*self.dots)
 130
 131         if factor <> Rational (1,1):
 132             str += '*%d/%d' % (factor.numerator (), factor.denominator ())
 133
 134         return str
 135
 136     def print_ly (self, outputter):
 137         str = self.ly_expression (self.factor / outputter.duration_factor ())
 138         outputter.print_duration_string (str)
 139
 140     def __repr__(self):
 141         return self.ly_expression()
 142
 143     def copy (self):
 144         d = Duration ()
 145         d.dots = self.dots
 146         d.duration_log = self.duration_log
 147         d.factor = self.factor
 148         return d
 149
 150     def get_length (self):
 151         dot_fact = Rational( (1 << (1 + self.dots))-1,
 152                              1 << self.dots)
 153
 154         log = abs (self.duration_log)
 155         dur = 1 << log
 156         if self.duration_log < 0:
 157             base = Rational (dur)
 158         else:
 159             base = Rational (1, dur)
 160
 161         return base * dot_fact * self.factor
 162
 163
 164 class Pitch:
 165     def __init__ (self):
 166         self.alteration = 0
 167         self.step = 0
 168         self.octave = 0
 169
 170     def __repr__(self):
 171         return self.ly_expression()
 172
 173     def transposed (self, interval):
 174         c = self.copy ()
 175         c.alteration  += interval.alteration
 176         c.step += interval.step
 177         c.octave += interval.octave
 178         c.normalize ()
 179
 180         target_st = self.semitones()  + interval.semitones()
 181         c.alteration += target_st - c.semitones()
 182         return c
 183
 184     def normalize (c):
 185         while c.step < 0:
 186             c.step += 7
 187             c.octave -= 1
 188         c.octave += c.step / 7
 189         c.step = c.step  % 7
 190
 191     def lisp_expression (self):
 192         return '(ly:make-pitch %d %d %d)' % (self.octave,
 193                                              self.step,
 194                                              self.alteration)
 195
 196     def copy (self):
 197         p = Pitch ()
 198         p.alteration = self.alteration
 199         p.step = self.step
 200         p.octave = self.octave
 201         return p
 202
 203     def steps (self):
 204         return self.step + self.octave *7
 205
 206     def semitones (self):
 207         return self.octave * 12 + [0,2,4,5,7,9,11][self.step] + self.alteration
 208
 209     def ly_step_expression (self):
 210         str = 'cdefgab'[self.step]
 211         if self.alteration > 0:
 212             str += 'is'* (self.alteration)
 213         elif self.alteration < 0:
 214             str += 'es'* (-self.alteration)
 215
 216         return str.replace ('aes', 'as').replace ('ees', 'es')
 217
 218     def ly_expression (self):
 219         str = self.ly_step_expression ()
 220         if self.octave >= 0:
 221             str += "'" * (self.octave + 1)
 222         elif self.octave < -1:
 223             str += "," * (-self.octave - 1)
 224
 225         return str
 226
 227     def print_ly (self, outputter):
 228         outputter (self.ly_expression())
 229
 230 class Music:
 231     def __init__ (self):
 232         self.parent = None
 233         self.start = Rational (0)
 234         self.comment = ''
 235         self.identifier = None
 236
 237     def get_length(self):
 238         return Rational (0)
 239
 240     def get_properties (self):
 241         return ''
 242
 243     def has_children (self):
 244         return False
 245
 246     def get_index (self):
 247         if self.parent:
 248             return self.parent.elements.index (self)
 249         else:
 250             return None
 251     def name (self):
 252         return self.__class__.__name__
 253
 254     def lisp_expression (self):
 255         name = self.name()
 256
 257         props = self.get_properties ()
 258
 259         return "(make-music '%s %s)" % (name,  props)
 260
 261     def set_start (self, start):
 262         self.start = start
 263
 264     def find_first (self, predicate):
 265         if predicate (self):
 266             return self
 267         return None
 268
 269     def print_comment (self, printer, text = None):
 270         if not text:
 271             text = self.comment
 272
 273         if not text:
 274             return
 275
 276         if text == '\n':
 277             printer.newline ()
 278             return
 279
 280         lines = string.split (text, '\n')
 281         for l in lines:
 282             if l:
 283                 printer.unformatted_output ('% ' + l)
 284             printer.newline ()
 285
 286
 287     def print_with_identifier (self, printer):
 288         if self.identifier:
 289             printer ("\\%s" % self.identifier)
 290         else:
 291             self.print_ly (printer)
 292
 293     def print_ly (self, printer):
 294         printer (self.ly_expression ())
 295
 296 class MusicWrapper (Music):
 297     def __init__ (self):
 298         Music.__init__(self)
 299         self.element = None
 300     def print_ly (self, func):
 301         self.element.print_ly (func)
 302
 303 class ModeChangingMusicWrapper (MusicWrapper):
 304     def __init__ (self):
 305         MusicWrapper.__init__ (self)
 306         self.mode = 'notemode'
 307
 308     def print_ly (self, func):
 309         func ('\\%s' % self.mode)
 310         MusicWrapper.print_ly (self, func)
 311
 312 class TimeScaledMusic (MusicWrapper):
 313     def print_ly (self, func):
 314         func ('\\times %d/%d ' %
 315            (self.numerator, self.denominator))
 316         func.add_factor (Rational (self.numerator, self.denominator))
 317         MusicWrapper.print_ly (self, func)
 318         func.revert ()
 319
 320 class NestedMusic(Music):
 321     def __init__ (self):
 322         Music.__init__ (self)
 323         self.elements = []
 324
 325     def append (self, what):
 326         if what:
 327             self.elements.append (what)
 328
 329     def has_children (self):
 330         return self.elements
 331
 332     def insert_around (self, succ, elt, dir):
 333         assert elt.parent == None
 334         assert succ == None or succ in self.elements
 335
 336
 337         idx = 0
 338         if succ:
 339             idx = self.elements.index (succ)
 340             if dir > 0:
 341                 idx += 1
 342         else:
 343             if dir < 0:
 344                 idx = 0
 345             elif dir > 0:
 346                 idx = len (self.elements)
 347
 348         self.elements.insert (idx, elt)
 349         elt.parent = self
 350
 351     def get_properties (self):
 352         return ("'elements (list %s)"
 353             % string.join (map (lambda x: x.lisp_expression(),
 354                       self.elements)))
 355
 356     def get_subset_properties (self, predicate):
 357         return ("'elements (list %s)"
 358             % string.join (map (lambda x: x.lisp_expression(),
 359                       filter ( predicate,  self.elements))))
 360     def get_neighbor (self, music, dir):
 361         assert music.parent == self
 362         idx = self.elements.index (music)
 363         idx += dir
 364         idx = min (idx, len (self.elements) -1)
 365         idx = max (idx, 0)
 366
 367         return self.elements[idx]
 368
 369     def delete_element (self, element):
 370         assert element in self.elements
 371
 372         self.elements.remove (element)
 373         element.parent = None
 374
 375     def set_start (self, start):
 376         self.start = start
 377         for e in self.elements:
 378             e.set_start (start)
 379
 380     def find_first (self, predicate):
 381         r = Music.find_first (self, predicate)
 382         if r:
 383             return r
 384
 385         for e in self.elements:
 386             r = e.find_first (predicate)
 387             if r:
 388                 return r
 389         return None
 390
 391 class SequentialMusic (NestedMusic):
 392     def print_ly (self, printer):
 393         printer ('{')
 394         if self.comment:
 395             self.print_comment (printer)
 396
 397         printer.newline()
 398         for e in self.elements:
 399             e.print_ly (printer)
 400
 401         printer ('}')
 402         printer.newline()
 403
 404     def lisp_sub_expression (self, pred):
 405         name = self.name()
 406
 407
 408         props = self.get_subset_properties (pred)
 409
 410         return "(make-music '%s %s)" % (name,  props)
 411
 412     def set_start (self, start):
 413         for e in self.elements:
 414             e.set_start (start)
 415             start += e.get_length()
 416
 417 class EventChord(NestedMusic):
 418     def get_length (self):
 419         l = Rational (0)
 420         for e in self.elements:
 421             l = max(l, e.get_length())
 422         return l
 423
 424     def print_ly (self, printer):
 425         note_events = [e for e in self.elements if
 426                isinstance (e, NoteEvent)]
 427
 428         rest_events = [e for e in self.elements if
 429                isinstance (e, RhythmicEvent)
 430                and not isinstance (e, NoteEvent)]
 431
 432         other_events = [e for e in self.elements if
 433                 not isinstance (e, RhythmicEvent)]
 434
 435         if rest_events:
 436             rest_events[0].print_ly (printer)
 437         elif len (note_events) == 1:
 438             note_events[0].print_ly (printer)
 439         elif note_events:
 440             pitches = [x.pitch.ly_expression () for x in note_events]
 441             printer ('<%s>' % string.join (pitches))
 442             note_events[0].duration.print_ly (printer)
 443         else:
 444             pass
 445
 446         for e in other_events:
 447             e.print_ly (printer)
 448
 449         self.print_comment (printer)
 450
 451
 452 class BarCheck (Music):
 453     def __init__ (self):
 454         Music.__init__ (self)
 455         self.bar_number = 0
 456
 457     def print_ly (self, printer):
 458         if self.bar_number > 0 and (self.bar_number % 10) == 0:
 459             printer.dump ("|  \\barNumberCheck #%d " % self.bar_number)
 460             printer.newline ()
 461         else:
 462             printer.dump ("| ")
 463             printer.print_verbatim (' %% %d' % self.bar_number)
 464             printer.newline ()
 465
 466
 467     def ly_expression (self):
 468         return " | "
 469
 470 class Event(Music):
 471     pass
 472
 473 class SpanEvent (Event):
 474     def __init__(self):
 475         Event.__init__ (self)
 476         self.span_direction = 0
 477     def get_properties(self):
 478         return "'span-direction  %d" % self.span_direction
 479
 480 class SlurEvent (SpanEvent):
 481     def ly_expression (self):
 482         return {-1: '(',
 483             0:'',
 484             1:')'}.get (self.span_direction, '')
 485
 486 class BeamEvent (SpanEvent):
 487     def ly_expression (self):
 488         return {-1: '[',
 489             0:'',
 490             1:']'}.get (self.span_direction, '')
 491
 492 class ArpeggioEvent(Event):
 493     def ly_expression (self):
 494         return ('\\arpeggio')
 495
 496
 497 class TieEvent(Event):
 498     def ly_expression (self):
 499         return '~'
 500
 501
 502 class HairpinEvent (Event):
 503     def __init__ (self, type):
 504         self.type = type
 505     def hairpin_to_ly (self):
 506         return { 0: '\!', 1: '\<', -1: '\>' }.get (self.type, '')
 507
 508     def ly_expression (self):
 509         return self.hairpin_to_ly ()
 510
 511     def print_ly (self, printer):
 512         val = self.hairpin_to_ly ()
 513         if val:
 514             printer.dump (val)
 515
 516
 517
 518 class DynamicsEvent (Event):
 519     def __init__ (self):
 520         self.type = None
 521         self.available_commands = [ "ppppp", "pppp", "ppp", "pp", "p",
 522                                     "mp", "mf",
 523                                     "f", "ff", "fff", "ffff",
 524                                     "fp", "sf", "sff", "sp", "spp", "sfz", "rfz" ];
 525     def ly_expression (self):
 526         if self.type == None:
 527             return;
 528         elif self.type in self.available_commands:
 529             return '\%s' % self.type
 530         else:
 531             return '\markup{ \dynamic %s }' % self.type
 532
 533     def print_ly (self, printer):
 534         if self.type == None:
 535             return
 536         elif self.type in self.available_commands:
 537             printer.dump ("\\%s" % self.type)
 538         else:
 539             printer.dump ("\\markup{ \\dynamic %s }" % self.type)
 540
 541
 542 class ArticulationEvent (Event):
 543     def __init__ (self):
 544         self.type = None
 545         self.force_direction = None
 546
 547     def direction_mod (self):
 548         return { 1: '^', -1: '_', 0: '-' }.get (self.force_direction, '')
 549
 550     def ly_expression (self):
 551         return '%s\\%s' % (self.direction_mod (), self.type)
 552
 553
 554 class TremoloEvent (Event):
 555     def __init__ (self):
 556         self.bars = 0;
 557
 558     def ly_expression (self):
 559         str=''
 560         if self.bars > 0:
 561             str += ':%s' % (2 ** (2 + string.atoi (self.bars)))
 562         return str
 563
 564
 565 class RhythmicEvent(Event):
 566     def __init__ (self):
 567         Event.__init__ (self)
 568         self.duration = Duration()
 569
 570     def get_length (self):
 571         return self.duration.get_length()
 572
 573     def get_properties (self):
 574         return ("'duration %s"
 575                 % self.duration.lisp_expression ())
 576
 577 class RestEvent (RhythmicEvent):
 578     def ly_expression (self):
 579         return 'r%s' % self.duration.ly_expression ()
 580
 581     def print_ly (self, printer):
 582         printer('r')
 583         self.duration.print_ly (printer)
 584
 585 class SkipEvent (RhythmicEvent):
 586     def ly_expression (self):
 587         return 's%s' % self.duration.ly_expression ()
 588
 589 class NoteEvent(RhythmicEvent):
 590     def  __init__ (self):
 591         RhythmicEvent.__init__ (self)
 592         self.pitch = None
 593         self.drum_type = None
 594         self.cautionary = False
 595         self.forced_accidental = False
 596
 597     def get_properties (self):
 598         str = RhythmicEvent.get_properties ()
 599
 600         if self.pitch:
 601             str += self.pitch.lisp_expression ()
 602         elif self.drum_type:
 603             str += "'drum-type '%s" % self.drum_type
 604
 605         return str
 606
 607     def pitch_mods (self):
 608         excl_question = ''
 609         if self.cautionary:
 610             excl_question += '?'
 611         if self.forced_accidental:
 612             excl_question += '!'
 613
 614         return excl_question
 615
 616     def ly_expression (self):
 617         if self.pitch:
 618             return '%s%s%s' % (self.pitch.ly_expression (),
 619                                self.pitch_mods(),
 620                                self.duration.ly_expression ())
 621         elif self.drum_type:
 622             return '%s%s' (self.drum_type,
 623                            self.duration.ly_expression ())
 624
 625     def print_ly (self, printer):
 626         if self.pitch:
 627             self.pitch.print_ly (printer)
 628             printer (self.pitch_mods ())
 629         else:
 630             printer (self.drum_type)
 631
 632         self.duration.print_ly (printer)
 633
 634 class KeySignatureChange (Music):
 635     def __init__ (self):
 636         Music.__init__ (self)
 637         self.scale = []
 638         self.tonic = Pitch()
 639         self.mode = 'major'
 640
 641     def ly_expression (self):
 642         return '\\key %s \\%s' % (self.tonic.ly_step_expression (),
 643                      self.mode)
 644
 645     def lisp_expression (self):
 646         pairs = ['(%d . %d)' % (i , self.scale[i]) for i in range (0,7)]
 647         scale_str = ("'(%s)" % string.join (pairs))
 648
 649         return """ (make-music 'KeyChangeEvent
 650      'pitch-alist %s) """ % scale_str
 651
 652 class TimeSignatureChange (Music):
 653     def __init__ (self):
 654         Music.__init__ (self)
 655         self.fraction = (4,4)
 656     def ly_expression (self):
 657         return '\\time %d/%d ' % self.fraction
 658
 659 class ClefChange (Music):
 660     def __init__ (self):
 661         Music.__init__ (self)
 662         self.type = 'G'
 663
 664
 665     def ly_expression (self):
 666         return '\\clef "%s"' % self.type
 667     clef_dict = {
 668         "G": ("clefs.G", -2, -6),
 669         "C": ("clefs.C", 0, 0),
 670         "F": ("clefs.F", 2, 6),
 671         }
 672
 673     def lisp_expression (self):
 674         (glyph, pos, c0) = self.clef_dict.get (self.type)
 675         clefsetting = """
 676         (make-music 'SequentialMusic
 677         'elements (list
 678    (context-spec-music
 679    (make-property-set 'clefGlyph "%s") 'Staff)
 680    (context-spec-music
 681    (make-property-set 'clefPosition %d) 'Staff)
 682    (context-spec-music
 683    (make-property-set 'middleCPosition %d) 'Staff)))
 684 """ % (glyph, pos, c0)
 685         return clefsetting
 686
 687
 688 class MultiMeasureRest(Music):
 689
 690     def lisp_expression (self):
 691         return """
 692 (make-music
 693   'MultiMeasureRestMusicGroup
 694   'elements
 695   (list (make-music (quote BarCheck))
 696         (make-music
 697           'EventChord
 698           'elements
 699           (list (make-music
 700                   'MultiMeasureRestEvent
 701                   'duration
 702                   %s)))
 703         (make-music (quote BarCheck))))
 704 """ % self.duration.lisp_expression ()
 705
 706     def ly_expression (self):
 707         return 'R%s' % self.duration.ly_expression ()
 708
 709
 710 def test_pitch ():
 711     bflat = Pitch()
 712     bflat.alteration = -1
 713     bflat.step =  6
 714     bflat.octave = -1
 715     fifth = Pitch()
 716     fifth.step = 4
 717     down = Pitch ()
 718     down.step = -4
 719     down.normalize ()
 720
 721
 722     print bflat.semitones()
 723     print bflat.transposed (fifth),  bflat.transposed (fifth).transposed (fifth)
 724     print bflat.transposed (fifth).transposed (fifth).transposed (fifth)
 725
 726     print bflat.semitones(), 'down'
 727     print bflat.transposed (down)
 728     print bflat.transposed (down).transposed (down)
 729     print bflat.transposed (down).transposed (down).transposed (down)
 730
 731
 732
 733 def test_printer ():
 734     def make_note ():
 735         evc = EventChord()
 736         n = NoteEvent()
 737         evc.append (n)
 738         return n
 739
 740     def make_tup ():
 741         m = SequentialMusic()
 742         m.append (make_note ())
 743         m.append (make_note ())
 744         m.append (make_note ())
 745
 746
 747         t = TimeScaledMusic ()
 748         t.numerator = 2
 749         t.denominator = 3
 750         t.element = m
 751         return t
 752
 753     m = SequentialMusic ()
 754     m.append (make_tup ())
 755     m.append (make_tup ())
 756     m.append (make_tup ())
 757
 758     printer = Output_printer()
 759     m.print_ly (printer)
 760     printer.newline ()
 761
 762 def test_expr ():
 763     m = SequentialMusic()
 764     l = 2
 765     evc = EventChord()
 766     n = NoteEvent()
 767     n.duration.duration_log = l
 768     n.pitch.step = 1
 769     evc.insert_around (None, n, 0)
 770     m.insert_around (None, evc, 0)
 771
 772     evc = EventChord()
 773     n = NoteEvent()
 774     n.duration.duration_log = l
 775     n.pitch.step = 3
 776     evc.insert_around (None, n, 0)
 777     m.insert_around (None, evc, 0)
 778
 779     evc = EventChord()
 780     n = NoteEvent()
 781     n.duration.duration_log = l
 782     n.pitch.step = 2
 783     evc.insert_around (None, n, 0)
 784     m.insert_around (None, evc, 0)
 785
 786     evc = ClefChange()
 787     evc.type = 'treble'
 788     m.insert_around (None, evc, 0)
 789
 790     evc = EventChord()
 791     tonic = Pitch ()
 792     tonic.step = 2
 793     tonic.alteration = -2
 794     n = KeySignatureChange()
 795     n.tonic=tonic.copy()
 796     n.scale = [0, 0, -2, 0, 0,-2,-2]
 797
 798     evc.insert_around (None, n, 0)
 799     m.insert_around (None, evc, 0)
 800
 801     return m
 802
 803
 804 if __name__ == '__main__':
 805     test_printer ()
 806     raise 'bla'
 807     test_pitch()
 808
 809     expr = test_expr()
 810     expr.set_start (Rational (0))
 811     print expr.ly_expression()
 812     start = Rational (0,4)
 813     stop = Rational (4,2)
 814     def sub(x, start=start, stop=stop):
 815         ok = x.start >= start and x.start +x.get_length() <= stop
 816         return ok
 817
 818     print expr.lisp_sub_expression(sub)
 819