music21

Audio applications in music21

2011-10-05T18:22:00.005-04:00

My name is Jordi Bartolomé Guillén and I spent this last summer collaborating at MIT in the music21 project. It was a fantastic experience for me!

I started my days in Cambridge learning music21 a little bit. First, I developed a converter from NoteWorthy Composer notation into music21.

Later, I developed different audio applications using music21:

- Transcriber: It is a software that records monophonic music and shows you the corresponding score in the laptop.

- Score Follower: It shows you the score that you want to play in the screen and, using the microphone of the laptop, detects which part of the score you are playing. Consequently, it slides the page automatically when it decides that is the best moment to do it.
Using this software you can play a song without having to slide the pages manually. It could be useful in concerts!

- Repetition game: Finally, I developed a two-people game which consists of the repetition of the note played by the other player and the addition of a new one. The player that fails first one of the notes loses the game!

These are some pictures of the applications. I hope you can enjoy them soon!

P.S.: Michael, Chris, Tina, Jose and Neena, thank you for this summer!

BMT: The All-Purpose Braille Music Transcriber

2011-09-29T13:16:00.005-04:00

I'm continuing my quest to develop an all-purpose Braille music transcriber in music21. This is a funding proposal submitted to the Undergraduate Research Opportunities Program (UROP) at MIT for the fall 2011 term. Hopefully by December we'll be able to transcribe chords into Braille!

________________________________________________________________________________

Reading and writing over the centuries has mostly relied on a person's ability to see. It was not until the 1800s that Louis Braille invented a system of raised dots that allowed the visually-impaired to read by substituting the sense of touch. In similar fashion, the blind have been deprived of playing and singing from musical scores for most of history, since reading and writing music on a staff also relies on the ability of sight. Fortunately, Braille also developed a system to represent written music as raised dots.

Braille music notation is noticeably different from the standard musical notation of representing notes on a staff, as shown below.

The "Happy Birthday" Song

⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠩⠼⠉⠲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀

⠼⠁⠀⠐⠑⠄⠵⠫⠱⠀⠳⠟⠀⠑⠄⠵⠫⠱⠀⠪⠗⠀⠑⠄⠵⠨⠱⠺⠀⠓⠄⠷⠻⠫⠀⠀⠀⠀⠀⠀

⠀⠀⠨⠙⠄⠽⠺⠳⠀⠪⠗⠣⠅

Braille music notation is not only different from standard musical notation, but also just as complex and difficult to master. Not only do blind persons need special training in reading Braille music notation, but those sighted persons seeking to transcribe music into Braille need extensive training in how the two notations correspond and where they differ.

This begs the question: what happens the day when a visually-impaired yet excellent singer wants to sing in the MIT Concert Choir? Assuming he or she is able to read Braille music notation, there needs to be a way of providing him or her with the translated repertoire.

One way of doing so is to invoke the services of a transcriber. However, because of the complexities explained beforehand, there are very few transcribers available to do this. Another solution is to use transcription software available on the open market. The problem is that said software tends to be very expensive. But what if there existed free software that could do the same? And that is exactly what the Braille music transcriber, BMT, I have been developing is.

I started developing BMT in July 2011 under a direct funding UROP as part of the music21 project, a project in MIT Music and Theater Arts which aims to develop software useful for musical analysis. Using knowledge borrowed from my years of training in both music and computer science, borrowing from code already written for music21, and consulting very closely with a certified Braille transcription manual[1], I have come up with a rudimentary transcriber.

Right now, BMT is capable of translating melodies such as the example presented beforehand––melodies containing musical elements including, but not limited to, notes, rests, bar lines, key signatures, and time signatures. Each of the musical elements corresponds to a Braille character or series of characters. Some more complex elements supported include fingering, slurs, changes of key or time signatures, and beaming. In short, most of the concepts in twelve of the first sixteen chapters of the transcription manual have been implemented, with more than 100 examples found within those chapters being transcribed correctly.

However, there is functionality that I aim to add during this UROP. The most notable of these is support for chords, or set of notes played or sung at once. Not only are chords omnipresent in keyboard music, but also harmonies of instruments in pieces with multiple parts played or sung in unison can always be boiled down to chords. Hence, chords are used as a method of instruction in musical composition classes not only at MIT but also at universities across the world. Implementing chords would be a big step towards being able to translate an introductory composition text such as Marjorie Merryman's The Music Theory Handbook[2] which is used at MIT. Chords and related concepts are covered over five chapters, approximately 100 pages, and are a leap beyond single melodies because one needs to deal with the vertical aspect and the horizontal aspect of the transcription simultaneously.

Another concept to implement is musical repeats, bar lines at the beginning and ending of sections which are meant to be repeated for a given piece of music. This is a relatively simple concept in print, but the manual spends three chapters covering it, approximately 100 pages.

Other important concepts to add include division of long measures whose transcription would fall at the end of a Braille line limited to forty characters in length, as well as increased support for musical expressions and special note modifiers such as ornaments. In fine, the first sixteen chapters comprise only 150 pages of a 500+ page manual––there is much to be done before BMT can "become an official Braille music transcriber."

With a completed BMT, all the editable musical scores available online will become available to visually-impaired musicians. As alpha code, the music21 project also benefits, because every example needs to be translated into music21 objects before being transcribed into Braille, uncovering plenty of bugs and resulting in many new features being implemented or improved upon. I also believe that new coding techniques developed will carry over towards my musical improvisation software whose further development is currently on hiatus.[3] But most of all, I believe that this project will continue to give me more of the engineering confidence which I have been seeking over the course of my time at MIT.

[1] Introduction to Braille Music Transcription, Second Edition 2005, by Mary Turner De Garmo, revised and edited by Lawrence R. Smith, Music Braille Transcriber.

[2] Marjorie Merryman. The Music Theory Handbook. Schirmer, 1996.

[3] Jose Cabal-Ugaz. fbRealizer: A 21st-Century Approach to a Centuries-Old Musical System. Cambridge, MA, 2011. UROP Summer Proposal.

Abjad v.2 released

2011-08-31T10:11:00.005-04:00

Woke up this morning to the great news that our friends Trevor Bača and Víctor Adán have released v.2 of their python-based, lilypond-powered, flexible music notation system Abjad (docs and installation instructions here). Abjad is a system for composers to build up scores from reusable, flexible elements and have precise control over notational elements. Some music21 users may have already noticed an "abj" directory in music21 and seen documentation at http://web.mit.edu/music21/doc/html/moduleAbjTranslate.html for how notes and simple streams can be translated from music21 to abjad. Since both projects use similar hierarchies including spanners and containers (Streams in music21), there is a lot of compatibility between the two. If a complete translator could be implemented (volunteers?), abjad would offer to music21 users high quality lilypond output and better tools for working with tuplets, staves with independent time signatures, and other rhythmic and layout tools that music21 does not yet have. Abjad users would gain access to music21's ability to parse many notational formats, work natively with intervals and harmonics, extensive scale collections (including Scala microtonal scales), and more. Getting these two projects closer to work more closely with each other is a win-win for everyone. Congrats to Trevor and Victor!

Nancarrow level tempo changes in music21

2011-08-30T13:12:00.006-04:00

The newest SVN releases (pre-alpha 12) of music21 include tempo change information to/from MIDI (we've already supported tempo i/o from musicxml since previous versions and read it in from Humdrum/Kern, Noteworthy, abc, Musedata and probably others. And newest releases export it to Braille Music Notation). Here's an example of using a tempo change after each note (default = quarter note) to create a smooth change of tempo (tracing a sine wave) from 60 bpm to 600 bpm over 60 notes.

from music21 import tempo, note, stream import math min = 60 max = 600 period = 50 s = stream.Stream() for i in range(100): scalar = (math.sin(i * (math.pi*2) / period) + 1) * .5 n = ((max-min) * scalar) + min s.append(tempo.MetronomeMark(number=n)) s.append(note.Note('g3')) s.show('midi')

And the output:

This feature lets you create pieces with the types of precise changes of tempo that Conlon Nancarrow painstakingly created in his piano-roll compositions. We'll soon have demos to show how you can use these features to create independent tempo marks in different parts to weave independent strands of music in your works. On the analytical side, importing precise tempo marks can open up new avenues for research on performance and interpretation, comparing the tempos chosen with those marked in the score.

To use the latest (not thoroughly tested) releases of music21 via SVN, we recommend developing using Eclipse. See Using Music21's SVN version with Eclipse. Otherwise, wait a few weeks for the latest release with lots of other improvements.

Alpha 11 released (and recent updates)

2011-08-23T16:17:00.001-04:00

I haven't done a good job keeping this blog abreast of changes to music21 lately, but there have been a ton. Here are the new features of alphas 9-11.

new in alpha 9

· IMPORTANT: corpus.parseWork() is now corpus.parse() to better match converter.parse()

· TimeSignatures’ .beatCount is now read-write. Additional partition options for MeterSequences.

· Added features to the RomanText format for specifying analyses (via Roman numerals) for pieces

· TimeSignatures can include “slow 6/8” “fast 6/8” etc. to specify if it’s a 6 or 2 beat measure.

· Better configuration options and configuration assistant

· node.py renamed to xmlnode.py – useful primarily if you’re writing a new translator for an xml-based format

· stripTies() has more options

· Changes to environment.UserSettings objects now propagate instantly (usually) so you can keep working without changing anything

· figuredBass.realizer() – new module for automatic realization of figured bass. (paper coming soon)

· text.TextExpression() class for handling most text expressions, with fonts etc. – can be positioned by quaterLength offsets to represent their occurring between beats. – displays properly in musicxml (thanks Michael Good for the help)

· bug fix: pitch.flipEnharmonic() no longer has octave problems.

· added subclasses of key.WeightKeyAnalysis for other weights such as AardenEssen and others (as discussed on this list recently)

· Key analyses routines now return a Key object with a .correlationCoefficient attribute (thanks Rachel Hall!)

· Dynamics objects can be freely positioned to take place between notes.

· plots now plot chords properly (please re-generate any old images that worked on chord data!)

· derviationChain() method and derivesFrom property on Streams will return the Stream that generated this one (via .flat, .notes, etc.) – a really useful method for Context checking.

· analysis/patel -- Tools for testing Aniruddh D. Patel's analysis theories, such as nPVI: Normalized Pairwise Variability Index and Melodic Interval Variability

· note.lyric – adding a lyric with a hyphen at the start or end will (unless overridden with applyRaw = True) automatically set it as a beginning or end syllable.

· Unicode accidentals via pitch.accidental.unicode

· MICROTONES! C~ = C-half-sharp, D` = D-half-flat. Microtone objects allow for setting any amount of cents between notes. Note that .ps now always returns a float representing the midi-note with microtonal precision. .frequency works with Microtones too!

· pitch.isTwelveTone() will say whether the note is a half-sharp, etc. or not.

· pitch.convertMicrotonesToQuarterTones() and pitch.convertQuarterTonesToMicrotones() let you decide if you want to represent C4 + 57cents as C4+57c or C~4+7c.

· harmonicFromFundamental() and harmonicAndFundamentalFromPitch() will let you get pitches representing, say the 7th harmonic of D#3 – with proper microtones! Or for spectral composers will let you find out potential fundamentals for a given pitch (with the number of cents off that this pitch is)

· Note.fullName, Duration.fullName, and Pitch.fullName gives a verbose description of the element

· Stream.recurse() will recursively find every element in the stream. What stream that element is in is set as .activeSite – this is different from .flat or .semiflat in that the .offset is still relative to the element’s container. recurse(streamsOnly = True) is a good way to only get substreams.

· chord.fromForteClass() will give you a chord (including “C4”) that matches the forteclass

· chord.fromIntervalVector() does the same thing if you have an interval vector. If it’s a Z-related chord, the first form of the chord is returned.

· chord.getZRelation() will return the other Z-related form of a chord.

· REPEATS! repeat.py has Repeat marks for dal segno, da capo, 1st 2nd (3rd 4th nth) endings, etc. all of which play back properly on .show. stream.expandRepeats() will expand repeats. (big plus on abc import)

· instrument.instrumentFromMidiProgram() gives a full-fledged music21 object given a midi program (0-127)

· stream.Transpose() is now recursive.

· better Mac installation docs.

new in apha 10

· Incompatible change: stream.notes now does not return rests; just notes and chords. Use stream.notesAndRests for the old functionality.

· improvements to Scale including new documentations to be presented at ICMC next month (links coming soon)

· FEATURE EXTRACTION: 60% of jSymbolic features and many native features implemented in the features modules. (paper to be presented soon – stay tuned!)

· Better docs for 64-bit windows and all tests pass on 64-bit systems.

· Expansions of ornaments – see expressions.realizeOrnaments()

· corpus includes Mozart and Haydn string quartets and more folk airs. (see acknowledgements for thanks)

· search.py – rhythmic (and future melodic) search module with wildcards (first version)

· musedata stage1 files are now supported

· Scala scales – scales that represent potentially microtonal scales from scala format. Music21 can now read any file in .scl format!

· Repeats are correctly translated in/out of musicxml

· Augmented 6th classification in chord.

Newest updates in alpha 11:

· Huge performance boost on stream manipulation – you’ll notice it just from using it.

· Repeat brackets display properly

· Improved abc conversion of pickup measures and repeats.

· Figured basses correctly handle resolutions of augmented 6ths and many other chords.

· Bug fixes on some accidental display output.

· transparent caching of streams (i.e., stream.flat will be faster the second call if the underlying stream hasn’t been changed)

· Empty voices (often outputted by Finale) are silently removed when converting from musicxml.

· Automatic correct MIDI channel distribution for instruments AND MICROTONAL PITCHBENDS! Your 19-tone piano trio should playback properly now (at least on the default synths on Mac and PC).

· medren – convertToHouseStyle and subroutines will change the default style for printing music to better reflect some editor’s ideas of proper representation of Renaissance music.

· makeChords – bug fix on overlapping rests.

· TimeSignatures and KeySignatures are imported properly from conductor tracks in midi import.

· ConcreteScale(pitches = ‘[pitchList’]) will now create a scale from the given pitches. Useful for treating a chord as an infinite scale of notes.

· tuning = ScalaScale(‘py12.scl’); tuning.tune(score) – will retune a score to a given temperament (with playback).

· Tempo import and export from music21 to musicxml

· additional corpus items (including incipits of 14th c. Virelais)

· most modules are now more unicode compliant.

Newest (super-beta features)

· Preliminary conversion of Noteworthy composer .nwctxt files (input only)

· Very preliminary output into Braille Music notation

· Noteheads are properly output from music21 (but not converted in yet).

And of course new demos, docs, and examples.

Check it all out at http://web.mit.edu/music21/

music21 on EchoNest

2011-04-18T17:55:00.004-04:00

Thanks to the work of Jonathan Marmor, music21 now has a proof-of-concept linking with The Echo Nest, a great mostly-open framework for audio analysis with many python links. See the Transcribe Melodies link for more information. Full source code is available here. Thanks to Jonathan and to Echo Nest for making this linkage possible. While music21's primary focus will always be on symbolic data, we love audio analysis and hope we can add more features to make music information retrieval and analysis on audio files easier.

http://the.echonest.com/platform/showcase/

Music Informatics at City University, London

2011-01-04T12:39:00.002-05:00

Passing on this good information from Tillman Weyde at City University, London:

The City University London is offering 75 Research Studentships to begin in October 2011. The Music Informatics research group in the Department of Computing at City University would particularly
like to encourage PhD applications in the area of Music Computing and Music Informatics.

Research interests in the Music Informatics research group include:

- music information retrieval
- computational musicology
- musical applications of machine learning
- semantic music representation
- systems and user interfaces for music e-learning and music information retrieval

Information about the Music Informatics research group and
the Research Studentship application procedures can be found
online at

http://www.soi.city.ac.uk/organisation/doc/research/mi/

and

http://www.city.ac.uk/research/resdegrees/studentships.html

The closing date for applications is the 31st January 2011.
If you are interested in applying get in touch with Tillman
Weyde (tweyde@uos.de) soon to discuss further details.

Mensural Canons and Other Applications of Stream Transformations

2010-06-15T13:18:00.007-04:00

We have a number of powerful Stream transformation methods available now, including transpose() and augmentOrDiminish(). My favorite task with such utilities is creating mensural canons. The example below does just that, using a Bach soprano line as the melodic source.

Further explanation can be found here:

http://mit.edu/music21/doc/html/examples.html

from music21 import *

src = corpus.parseWork('bach/bwv323.xml')

ex = src.getElementById('Soprano').flat.notes

s = stream.Score()

for scalar, t in [(1, 'p1'), (2, 'p-5'), (.5, 'p-11'), (1.5, -24)]:

part = ex.augmentOrDiminish(scalar, inPlace=False)

part.transpose(t, inPlace=True)

s.insert(0, part)

s.show()

New Documentation Chapter on Meters

2010-06-15T09:27:00.004-04:00

We have a new documentation chapter, with numerous examples and demonstrations, on using and processing time signatures and meter-related data:

http://mit.edu/music21/doc/html/overviewMeters.html

Meter Objects at ICMC 2010

2010-06-04T18:57:00.003-04:00

This week we presented a paper on music21 Meter objects at the 2010 International Computer Music Conference. There were a number of people happy to see an easy-to-use, powerful, object-oriented representation of symbolic musical structures.

The paper can be downloaded at the link below. I will be posting a few examples, and a new documentation tutorial, in the coming days.

http://mit.edu/music21/papers/2010MeterObjects.pdf

Music21 Launch!

2010-05-21T07:53:00.005-04:00

Music21 has released its first Alpha for download. The site is up at http://web.mit.edu/music21/. As an alpha release many of the features are not yet enabled and the documentation is not complete, but don't expect it ever to be since we're constantly expanding and developing the code. We plan on keeping the main syntax for Notes, Chords, and Streams exactly as it is -- it's been over two year's worth of work and refinements to get it where it is, and I think you'll be pleased. MusicXML import and export are quite well-developed and most rudimentary Humdrum/Kern support is there. Join the music21 mailing list at Google Groups to give feedback and ask questions.

music21: Visualizing Messiaen’s Mode de valeurs

2010-04-01T15:14:00.003-04:00

Oliver Messiaen (1908–1992) was one of the most innovative and interesting composers of the twentieth century. He worked birdsong deep into the fabric of his pieces. He played with rhythms (some descended from Hindu chant) that sounded the same forwards and backwards. And he created a whole new style of composition for the organ, invigorating the repertoire for this venerable instrument.

One of the most influential of Messiaen’s innovation was extending the ideals of twelve-tone music to go beyond pitch. The twelve-tone method, as developed Arnold Schoenberg and his followers, involved arranging pitches in fixed orders so that each note would have equal prominence and the tendency to write music too-mired in the sounds of the past would be eliminated (or at least greatly reduced). While much of the musical world reacted (and still reacts) to Schoenberg by believing he went too far in alienating modern music from the past, Messiaen and a small group of (at the time) young composers believed that he did not go far enough. By not organizing rhythms and loudness (called dynamics or, in French, intensités) similarly to the way he had serialized pitch, Schoenberg’s music could still be rooted in the rhythms and swells of the past.

Messiaen’s 1949 piece “Mode de valeurs et d’intensités” from Quatre études de rythme (“Organization of durations and dynamics” from Four studies in rhythm) was the first European work of “total serialism.” (In America, the composer Milton Babbitt had already made independent but similar creative discoveries). In this piece for piano, three “rows” are used simultaneously. Each pitch in each row is then assigned a particular duration and dynamic that always appears with that pitch (and only with that pitch.) Within each row, the durations get longer as notes get lower.

The precise relationship between pitch and duration is often hard to imagine when looking at the score, but with music21 these relationships become obvious. This code runs a Finale version of the score for the middle row of the Messiaen piece through our graphing tools:

messiaen = converter.parse('d:/desktop/messiaen_valeurs.xml')
messiaen.show()
notes = messiaen.flat.stripTies()
g = graph.PlotScatterWeightedPitchSpaceQuarterLength(notes, 
        title='Messiaen, Mode de Valeurs, middle voice', xLog=False)
g.process()

The 1:1 correspondence between pitch and duration is obvious: each pitch has exactly one quarter length associated with it, and the lengths get longer as the pitch descends. But the non-serially determined aspects of the score are equally obvious. Unlike Schoenberg’s ideal of using each pitch the same number of times, higher pitches appear much more often in the Messiaen piece. But the correspondence is not perfect. For instance, the pitch D 4 appears 11 times while the higher E-flat 4 appears only 10 times. For the most part, the amount of time that each pitch is sounded is roughly constant – at around 20 quarter-notes. But the two shortest notes (G5 and C5) appear as outliers to this theory, appearing only for about 9 and 13 quarters respectively.

What also jumps out in the graph is its shape: it is cubic, that is, it approximates the graph of f(x) = –x³. There are several functions in nature and human society that are modeled by cubic equations, such as magnetic strength, the twisting force of rubber bands (like in wind-up toy planes), and the costs involved with manufacturing. One example from one piece is of course nowhere near enough evidence to suggest that post-tonal pitch and duration relationships could be another place where cubic equations might guide composers. But it does give an idea for further research. As more serial and other post-tonal compositions are inputted into machine-readable formats, I’ll be checking back with whether this relationship holds often enough in Messiaen and other’s music to be significant.

The code for this example has been submitted to the International Symposium on Music Information Retrieval as part of a proposed paper on the music21 system.

TimeMap by Cuthbert and Natasha Skowronski

2010-03-31T03:42:00.003-04:00

One of the hardest parts of learning music history (and I suppose art and other histories as well) is that though styles change over time, the changes happen extremely scattered with little uniformity. Thus students tend to believe that a more "advanced" sounding piece was composed later than a "simpler" sounding one, when the opposite is also extremely likely to be true. One of the biggest recurring problems for learning style in Early Music, for instance, is that the most commonly studied pieces in English Renaissance style are being composed at the same time or after the Italians created new techniques of recitative, basso continuo, and other markers of the Baroque.

This Timeline + Map, developed by myself and Natasha Skowronski (MIT '10) allows viewers to see what pieces were being composed at the same time or in close geographical spans of each other. Each piece (taken from a mix of my syllabus and Craig Wright's Music in Western Civilization) has a thirty second excerpt online while a few have associated YouTube videos. (Students in the class can hear whole pieces). Click the image below to investigate further.

Leading tone analysis

2010-01-11T16:35:00.002-05:00

I just discovered that I missed the main point of Christopher Ariza's program (posted earlier) to find all the C#s in a Bach chorale. His code demonstrates that in this chorale Bach uses raised leading tones only on beats one and three, the two strongest beats in the measure. As music21's key detection algorithms and context objects come online, you'll soon be able to substitute the explicit coding of "C#" for:


   if note.pitch == note.getContextByClass(Key).scaleDegree("#7"):

We're almost there... just hang tight a few more months.

How high do your singers need to sing to do this piece?

2009-12-26T18:41:00.007-05:00

Here's one way of figuring it out:

(see the original blog post if your reposting turns this code into goobley-gook...)


import copy
import music21
from music21 import corpus, meter, stream
    
score = corpus.parseWork('bach/bwv366')
ts = score.flat.getElementsByClass(meter.TimeSignature)[0]
ts.beat.partition(3)
    
found = stream.Stream()
for part in score:
    found.append(part.flat.getElementsByClass(music21.clef.Clef)[0])
    highestNoteNum = 0
    for m in part.measures:
        for n in m.notes:
            if n.midi > highestNoteNum:
                highestNoteNum = n.midi
                highestNote = copy.deepcopy(n) # optional
  
                # These two lines will keep the look of the original
                # note values but make each note 1 4/4 measure long:    
                highestNote.duration.components[0].unlink()
                highestNote.quarterLength = 4

                highestNote.lyric = '%s: M. %s: beat %s' % (
                    part.getInstrument().partName[0], 
                    m.measureNumber, ts.getBeat(n.offset))
    found.append(highestNote)

found.show()

... which generates this snippet of notation...

...showing that for at least one piece, Bach was (probably accidentally) using the old medieval authentic, plagal, lower-octave-authentic, lower-octave-plagal, range designations!

This code is still needlessly complicated -- we're still working on simplifying it (notes will know their own clefs and beats; '3/4' will know that it should be divided into 1+1+1), but just a little taste of what's possible.

~~Oh, and just for fun, all the C#s in the piece with this code snippet substitution:~~. Or discover that all the raised leading tones in this d-minor composition happen on the two strongest beat of a measure:


             if n.name == 'C#':
                ...
                found.append(n)

Mapping the Eroica

2009-12-19T11:23:00.002-05:00

Alex Ross discusses on his blog a project by Eric Grunin to document changes in the performance of Beethoven's Eroica Symphony over the years. His visualization of changes in tempo in the first movement over time are particularly interesting:

(Red dots represent performances that take the repeat at the end of the exposition; blue dots do not).

Grunin finds all sorts of new and interesting data to analyze. I especially wanted to link to it to show that there is a lot of amazing projects in computer-aided musicology still to be done that do not require the use of analysis of music as symbolic data (as music21 does)

How do Mozart and Chopin use their notes?

2009-12-10T17:51:00.004-05:00

Mozart's minuets don't sound much like Chopin's mazurkas. There are many reasons for this -- the rhythms, the tone of their pianos, changes in repetition, and so on. But one of the ways that music21 let us discover is that they articulate their pitch space differently. For instance, here is the pitch distribution in the soprano register of one minuet by Mozart:

The x (left<->right) axis shows shorter and longer notes -- this excerpt [like the Chopin] uses almost entirely quarter notes (1.0) and eighth notes (0.5 quarterLength). The y (front<->back) axis shows lower to higher notes (middle C = 60). The z (top<->bottom) axis shows the number of times each pitch/rhythm combination appears. Looking along the y axis, we see something like a bell-shaped curve. Mozart uses notes in the middle of the register the most often, followed by a smooth trailing off towards higher and lower notes.

Contrast the Mozart graph with the pitch distribution of the right hand of a Chopin mazurka:

Chopin emphasizes certain notes quite a bit more than other notes. There is no smooth distribution; instead some pitch-classes (C# and G# especially) recur much more often in certain registers of the piano. We will be returning to these examples (probably refining the graphs slightly to deal better with grace-notes, etc.) as music21 moves toward its initial beta release.

Expressive Notation Package

2009-11-18T17:53:00.007-05:00

A potentially interesting article on some of the challenges of music notation. Things that we're thinking about while creating a system that encodes much of the ambiguity and power of music notation

ENP: A System for Contemporary Music Notation

Simple things simple

2009-10-30T18:26:00.005-04:00

(1)


from music21 import serial

p = [8,1,7,9,0,2,3,5,4,11,6,10]
print serial.rowToMatrix(p)

  0  5 11  1  4  6  7  9  8  3 10  2
  7  0  6  8 11  1  2  4  3 10  5  9
  1  6  0  2  5  7  8 10  9  4 11  3
 11  4 10  0  3  5  6  8  7  2  9  1
  8  1  7  9  0  2  3  5  4 11  6 10
  6 11  5  7 10  0  1  3  2  9  4  8
  5 10  4  6  9 11  0  2  1  8  3  7
  3  8  2  4  7  9 10  0 11  6  1  5
  4  9  3  5  8 10 11  1  0  7  2  6
  9  2  8 10  1  3  4  6  5  0  7 11
  2  7  1  3  6  8  9 11 10  5  0  4
 10  3  9 11  2  4  5  7  6  1  8  0

(2) We want to graphically show correlations between the length of notes and their heights using a piece coded in musicxml or humdrum format (these are from our downloaded corpora):


for work in ['opus18no1', 'opus59no3']:
    movementNumber = 3
    score = corpus.parseWork(work, movementNumber)
    
    for part in score:
        instrumentName = part.getElementsByClass(instrument.Instrument)[0].findName()
        grapher = correlate.NoteAnalysis(part.flat.sorted)    
        grapher.pitchToLengthScatter(title='%s, Movement %s, %s' % (work, movementNumber, instrumentName))

Displays 8 images, including:

Music21 Preview -- Welcome! Creating measures

2009-10-30T17:40:00.002-04:00

This is a preview of the music21 system for computer-aided musicology being developed at MIT (Michael Scott Cuthbert, Asst. Prof., Principal Investigator; Christopher Ariza, Visiting Asst. Prof., Development Lead). We'll be using this blog to showcase some of the features of the system, and to highlight other interesting things happening in computational, statistical, and other empirical methods in musicology.

Although computers have transformed how we listen to, obtain, compose, and notate music, they have not fundamentally changed how we research and analyze music. Though many computer databases have been created for musicology, they are not well adapted for sophisticated music queries. For instance, melodies can be found if exact matches exist. But melodic variations such as the repetition of a phrase or a change in embellishment are extremely common, yet cause searches to fail. More complex investigations, such as finding all melodies that imply a particular underlying harmony, can barely begin to be created with existing software packages. The lack of relevant software for analyzing music hampers scientific attempts to understand what we listen for and how we process what we hear; these activities are little understood despite music’s nearly universal presence in our daily lives.

The music21 project at M.I.T. will give to the music community the set of tools it needs to conduct sophisticated musical and statistical analysis using modern programming techniques. The software framework, written in Python, manipulates music as a collection of symbolic data, such as pitch names and note durations, that can then be classified as higher level musical structures according to the style, region, or period being studied.

Music21 focuses specifically on the manipulation of symbolic music data: it leaves to the many preexisting open-source and proprietary software packages the notation and audio playback of scores (the two areas where computer-aided music research is most developed). By focusing on the points of greatest need to musicology, the framework will give rapid results within a short timeframe.

The music21 framework will be freely available in early 2010 under the LGPL open source license.

Some demos:


from music21 import *

n = note.Note("F#4")
n.quarterLength = 3

a = stream.Stream()
a.repeatAdd(n, 20)  # add 20 copies of n

a.insertAtOffset( 0, meter.TimeSignature("5/4")) 
a.insertAtOffset(10, meter.TimeSignature("2/4")) 
a.insertAtOffset( 3, meter.TimeSignature("3/16")) 
# N.B.they don't have to be inserted in order 

a.insertAtOffset(20, meter.TimeSignature("9/8")) 
a.insertAtOffset(40, meter.TimeSignature("10/4"))
a.insertAtOffset(50, meter.TimeSignature("29/32"))
a.show()

Click to expand