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 Lyrics:
 418     def __init__ (self):
 419         self.lyrics_syllables = []
 420
 421     def print_ly (self, printer):
 422         printer.dump ("\lyricmode {")
 423         for l in self.lyrics_syllables:
 424             printer.dump ( "%s " % l )
 425         printer.dump ("}")
 426
 427     def ly_expression (self):
 428         lstr = "\lyricmode {\n  "
 429         for l in self.lyrics_syllables:
 430             lstr += l + " "
 431         lstr += "\n}"
 432         return lstr
 433
 434
 435 class EventChord(NestedMusic):
 436     def get_length (self):
 437         l = Rational (0)
 438         for e in self.elements:
 439             l = max(l, e.get_length())
 440         return l
 441
 442     def print_ly (self, printer):
 443         note_events = [e for e in self.elements if
 444                isinstance (e, NoteEvent)]
 445
 446         rest_events = [e for e in self.elements if
 447                isinstance (e, RhythmicEvent)
 448                and not isinstance (e, NoteEvent)]
 449
 450         other_events = [e for e in self.elements if
 451                 not isinstance (e, RhythmicEvent)]
 452
 453         if rest_events:
 454             rest_events[0].print_ly (printer)
 455         elif len (note_events) == 1:
 456             note_events[0].print_ly (printer)
 457         elif note_events:
 458             pitches = [x.pitch.ly_expression () for x in note_events]
 459             printer ('<%s>' % string.join (pitches))
 460             note_events[0].duration.print_ly (printer)
 461         else:
 462             pass
 463
 464         for e in other_events:
 465             e.print_ly (printer)
 466
 467         self.print_comment (printer)
 468
 469
 470 class BarCheck (Music):
 471     def __init__ (self):
 472         Music.__init__ (self)
 473         self.bar_number = 0
 474
 475     def print_ly (self, printer):
 476         if self.bar_number > 0 and (self.bar_number % 10) == 0:
 477             printer.dump ("|  \\barNumberCheck #%d " % self.bar_number)
 478             printer.newline ()
 479         else:
 480             printer.dump ("| ")
 481             printer.print_verbatim (' %% %d' % self.bar_number)
 482             printer.newline ()
 483
 484
 485     def ly_expression (self):
 486         return " | "
 487
 488 class Event(Music):
 489     pass
 490
 491 class SpanEvent (Event):
 492     def __init__(self):
 493         Event.__init__ (self)
 494         self.span_direction = 0
 495     def get_properties(self):
 496         return "'span-direction  %d" % self.span_direction
 497
 498 class SlurEvent (SpanEvent):
 499     def ly_expression (self):
 500         return {-1: '(',
 501             0:'',
 502             1:')'}.get (self.span_direction, '')
 503
 504 class BeamEvent (SpanEvent):
 505     def ly_expression (self):
 506         return {-1: '[',
 507             0:'',
 508             1:']'}.get (self.span_direction, '')
 509
 510 class ArpeggioEvent(Event):
 511     def ly_expression (self):
 512         return ('\\arpeggio')
 513
 514
 515 class TieEvent(Event):
 516     def ly_expression (self):
 517         return '~'
 518
 519
 520 class HairpinEvent (Event):
 521     def __init__ (self, type):
 522         self.type = type
 523     def hairpin_to_ly (self):
 524         return { 0: '\!', 1: '\<', -1: '\>' }.get (self.type, '')
 525
 526     def ly_expression (self):
 527         return self.hairpin_to_ly ()
 528
 529     def print_ly (self, printer):
 530         val = self.hairpin_to_ly ()
 531         if val:
 532             printer.dump (val)
 533
 534
 535
 536 class DynamicsEvent (Event):
 537     def __init__ (self):
 538         self.type = None
 539         self.available_commands = [ "ppppp", "pppp", "ppp", "pp", "p",
 540                                     "mp", "mf",
 541                                     "f", "ff", "fff", "ffff",
 542                                     "fp", "sf", "sff", "sp", "spp", "sfz", "rfz" ];
 543     def ly_expression (self):
 544         if self.type == None:
 545             return;
 546         elif self.type in self.available_commands:
 547             return '\%s' % self.type
 548         else:
 549             return '\markup{ \dynamic %s }' % self.type
 550
 551     def print_ly (self, printer):
 552         if self.type == None:
 553             return
 554         elif self.type in self.available_commands:
 555             printer.dump ("\\%s" % self.type)
 556         else:
 557             printer.dump ("\\markup{ \\dynamic %s }" % self.type)
 558
 559
 560 class ArticulationEvent (Event):
 561     def __init__ (self):
 562         self.type = None
 563         self.force_direction = None
 564
 565     def direction_mod (self):
 566         return { 1: '^', -1: '_', 0: '-' }.get (self.force_direction, '')
 567
 568     def ly_expression (self):
 569         return '%s\\%s' % (self.direction_mod (), self.type)
 570
 571
 572 class TremoloEvent (Event):
 573     def __init__ (self):
 574         self.bars = 0;
 575
 576     def ly_expression (self):
 577         str=''
 578         if self.bars > 0:
 579             str += ':%s' % (2 ** (2 + string.atoi (self.bars)))
 580         return str
 581
 582
 583 class RhythmicEvent(Event):
 584     def __init__ (self):
 585         Event.__init__ (self)
 586         self.duration = Duration()
 587
 588     def get_length (self):
 589         return self.duration.get_length()
 590
 591     def get_properties (self):
 592         return ("'duration %s"
 593                 % self.duration.lisp_expression ())
 594
 595 class RestEvent (RhythmicEvent):
 596     def ly_expression (self):
 597         return 'r%s' % self.duration.ly_expression ()
 598
 599     def print_ly (self, printer):
 600         printer('r')
 601         self.duration.print_ly (printer)
 602
 603 class SkipEvent (RhythmicEvent):
 604     def ly_expression (self):
 605         return 's%s' % self.duration.ly_expression ()
 606
 607 class NoteEvent(RhythmicEvent):
 608     def  __init__ (self):
 609         RhythmicEvent.__init__ (self)
 610         self.pitch = None
 611         self.drum_type = None
 612         self.cautionary = False
 613         self.forced_accidental = False
 614
 615     def get_properties (self):
 616         str = RhythmicEvent.get_properties ()
 617
 618         if self.pitch:
 619             str += self.pitch.lisp_expression ()
 620         elif self.drum_type:
 621             str += "'drum-type '%s" % self.drum_type
 622
 623         return str
 624
 625     def pitch_mods (self):
 626         excl_question = ''
 627         if self.cautionary:
 628             excl_question += '?'
 629         if self.forced_accidental:
 630             excl_question += '!'
 631
 632         return excl_question
 633
 634     def ly_expression (self):
 635         if self.pitch:
 636             return '%s%s%s' % (self.pitch.ly_expression (),
 637                                self.pitch_mods(),
 638                                self.duration.ly_expression ())
 639         elif self.drum_type:
 640             return '%s%s' (self.drum_type,
 641                            self.duration.ly_expression ())
 642
 643     def print_ly (self, printer):
 644         if self.pitch:
 645             self.pitch.print_ly (printer)
 646             printer (self.pitch_mods ())
 647         else:
 648             printer (self.drum_type)
 649
 650         self.duration.print_ly (printer)
 651
 652 class KeySignatureChange (Music):
 653     def __init__ (self):
 654         Music.__init__ (self)
 655         self.scale = []
 656         self.tonic = Pitch()
 657         self.mode = 'major'
 658
 659     def ly_expression (self):
 660         return '\\key %s \\%s' % (self.tonic.ly_step_expression (),
 661                      self.mode)
 662
 663     def lisp_expression (self):
 664         pairs = ['(%d . %d)' % (i , self.scale[i]) for i in range (0,7)]
 665         scale_str = ("'(%s)" % string.join (pairs))
 666
 667         return """ (make-music 'KeyChangeEvent
 668      'pitch-alist %s) """ % scale_str
 669
 670 class TimeSignatureChange (Music):
 671     def __init__ (self):
 672         Music.__init__ (self)
 673         self.fraction = (4,4)
 674     def ly_expression (self):
 675         return '\\time %d/%d ' % self.fraction
 676
 677 class ClefChange (Music):
 678     def __init__ (self):
 679         Music.__init__ (self)
 680         self.type = 'G'
 681
 682
 683     def ly_expression (self):
 684         return '\\clef "%s"' % self.type
 685     clef_dict = {
 686         "G": ("clefs.G", -2, -6),
 687         "C": ("clefs.C", 0, 0),
 688         "F": ("clefs.F", 2, 6),
 689         }
 690
 691     def lisp_expression (self):
 692         (glyph, pos, c0) = self.clef_dict.get (self.type)
 693         clefsetting = """
 694         (make-music 'SequentialMusic
 695         'elements (list
 696    (context-spec-music
 697    (make-property-set 'clefGlyph "%s") 'Staff)
 698    (context-spec-music
 699    (make-property-set 'clefPosition %d) 'Staff)
 700    (context-spec-music
 701    (make-property-set 'middleCPosition %d) 'Staff)))
 702 """ % (glyph, pos, c0)
 703         return clefsetting
 704
 705
 706 class MultiMeasureRest(Music):
 707
 708     def lisp_expression (self):
 709         return """
 710 (make-music
 711   'MultiMeasureRestMusicGroup
 712   'elements
 713   (list (make-music (quote BarCheck))
 714         (make-music
 715           'EventChord
 716           'elements
 717           (list (make-music
 718                   'MultiMeasureRestEvent
 719                   'duration
 720                   %s)))
 721         (make-music (quote BarCheck))))
 722 """ % self.duration.lisp_expression ()
 723
 724     def ly_expression (self):
 725         return 'R%s' % self.duration.ly_expression ()
 726
 727
 728 def test_pitch ():
 729     bflat = Pitch()
 730     bflat.alteration = -1
 731     bflat.step =  6
 732     bflat.octave = -1
 733     fifth = Pitch()
 734     fifth.step = 4
 735     down = Pitch ()
 736     down.step = -4
 737     down.normalize ()
 738
 739
 740     print bflat.semitones()
 741     print bflat.transposed (fifth),  bflat.transposed (fifth).transposed (fifth)
 742     print bflat.transposed (fifth).transposed (fifth).transposed (fifth)
 743
 744     print bflat.semitones(), 'down'
 745     print bflat.transposed (down)
 746     print bflat.transposed (down).transposed (down)
 747     print bflat.transposed (down).transposed (down).transposed (down)
 748
 749
 750
 751 def test_printer ():
 752     def make_note ():
 753         evc = EventChord()
 754         n = NoteEvent()
 755         evc.append (n)
 756         return n
 757
 758     def make_tup ():
 759         m = SequentialMusic()
 760         m.append (make_note ())
 761         m.append (make_note ())
 762         m.append (make_note ())
 763
 764
 765         t = TimeScaledMusic ()
 766         t.numerator = 2
 767         t.denominator = 3
 768         t.element = m
 769         return t
 770
 771     m = SequentialMusic ()
 772     m.append (make_tup ())
 773     m.append (make_tup ())
 774     m.append (make_tup ())
 775
 776     printer = Output_printer()
 777     m.print_ly (printer)
 778     printer.newline ()
 779
 780 def test_expr ():
 781     m = SequentialMusic()
 782     l = 2
 783     evc = EventChord()
 784     n = NoteEvent()
 785     n.duration.duration_log = l
 786     n.pitch.step = 1
 787     evc.insert_around (None, n, 0)
 788     m.insert_around (None, evc, 0)
 789
 790     evc = EventChord()
 791     n = NoteEvent()
 792     n.duration.duration_log = l
 793     n.pitch.step = 3
 794     evc.insert_around (None, n, 0)
 795     m.insert_around (None, evc, 0)
 796
 797     evc = EventChord()
 798     n = NoteEvent()
 799     n.duration.duration_log = l
 800     n.pitch.step = 2
 801     evc.insert_around (None, n, 0)
 802     m.insert_around (None, evc, 0)
 803
 804     evc = ClefChange()
 805     evc.type = 'treble'
 806     m.insert_around (None, evc, 0)
 807
 808     evc = EventChord()
 809     tonic = Pitch ()
 810     tonic.step = 2
 811     tonic.alteration = -2
 812     n = KeySignatureChange()
 813     n.tonic=tonic.copy()
 814     n.scale = [0, 0, -2, 0, 0,-2,-2]
 815
 816     evc.insert_around (None, n, 0)
 817     m.insert_around (None, evc, 0)
 818
 819     return m
 820
 821
 822 if __name__ == '__main__':
 823     test_printer ()
 824     raise 'bla'
 825     test_pitch()
 826
 827     expr = test_expr()
 828     expr.set_start (Rational (0))
 829     print expr.ly_expression()
 830     start = Rational (0,4)
 831     stop = Rational (4,2)
 832     def sub(x, start=start, stop=stop):
 833         ok = x.start >= start and x.start +x.get_length() <= stop
 834         return ok
 835
 836     print expr.lisp_sub_expression(sub)
 837