Example Instances of the TScore Project Infrastructure
ml

TScore is a novel data format (and its Java-based implementation) which allows to directly write down time-related data models. It is intended for a fast, easily readable, and compact representation of very different kinds of music data. But it is also applicable to any other kind of time-related data, like cue lists, stage light and effect control, synthesizer parameter curves, etc.

It follows the paradigm of conventional multi-voice music notation: Time flows from left to right, possibly broken into "staves"---voices and their parameter tracks are stacked vertically.

TScore is a meta-meta-model. It is a toolkit which allows with very few lines of code to construct a meta-model to define the syntax and the semantics of the input format which fits best a particular modelling project:

1. The resulting notation for the models is utmost compact, because only the relevant aspects need to be written. (We entered the whole "Die Kunst der Fuge" in less then four days.)
2. The notation is pure text. It can be read easily by humans and machines. It does not need tool support but can be written with pen and pencil only. (which of course are tools !-)
3. The semantics of the notation and of the implementation is well-defined and public. Nothing happens behind the scenes. The source text of the implementation is open and in the public domain.
4. The software architecture itself claims to be subject of and means for research: In contrast to all other tools for music notation (which seen from professional computer science are all very "hacky") the clean stratification of the different states of the evaluation pipelines (Lepper 2021) is reflected in its algorithms and data structures.
5. The underlying time model is pluggable, and so are all parameter values. Whenever in course of a modelling project further parameters turn out as necessary (e.g. editor comments, variants, analytical annotations), these can easily be added as further parameter tracks, without compatibility issues.

The following examples show the wide range of applications. Please note that only few pages (or even lines) of code are necessary to adopt TScore to the very different meta-models.
For opening the Java and Tscore source files choose any text editor.
For understanding the TScore files they must be presented with a fixed size / teletype font and with sufficient width of the editor window.

Our latest finished project re-models Morton Feldman Projections 1--5.. Our digital model allowed automated graphical rendering, statistical analyses, and even automated execution.

1. TENOR 2024 pages 121--132 = published contribution; see there for source text examples, rendered output, and statistical data.
2. Complete suurce text of the model definition.
3. Complete tscore of one of the Feldman pieces.
4. Description page which also links to the executable implementation. Start this for source and rendered examples, and for automated MIDI execution.

Most recent (just started and ongoing) project is the tool support for "TabStaff+", a notation for "Tangible User Interfaces", defined by White and Wilde (2024) and presented on the Tenor 24 Conference in Zürich, proceedings pg 159--168:

1. Java source defining the score's semantics,
2. Java source defining the translation into conventional tablature notation.
3. Input Score
4. Animated visual result
5. Executable Code (PROVISIONAL!)

A very tiny but successfully finished project is an application to German Lute Tablature. (Inspired by a talk by Reinier de Valk on the TEIMEC 2023 conference in Paderborn)

1. Java source text, complete for model definition, rendering, and xml export.
2. Quelltext, xml export, and (control) rendering for one example from the famous book by Wolf (1919).
3. Quelltext, xml export, and (control) rendering for another example.

The currently ongoing of the bigger applications is a the modeling of Johann Sebastian Bachs Die Kunst der Fuge. It is not yet complete (ornaments are missing; canons etc. are not yet expanded), but is already employed for rendering (to lilypond), automated analysis, and sound synthesis.

Here is the rendered output (thanx to lilypond): kdf.pdf.

Here follow the tscore source text. As always, you need a monospace font. And here you need at approx. 120 screen columns (best use emacs!-)
cp01.cwn cp02.cwn cp03.cwn cp04.cwn cp05.cwn cp06.cwn cp07.cwn cp08.cwn cp09.cwn cp10.cwn cp11.cwn cp12.cwn cp13.cwn cp14.cwn cp15.cwn cp16.cwn cp17.cwn cp18.cwn
(We follow the Gräser edition, but drop his dubious "Cp XVII for two cembali".)

The implementation is still under development but already allows to play some of the fugues, with the synthi controlled by the user.

Our intention is to apply automated analysis and search for symmetric chords, seperately in sound and notation. This will be easy thanks to the clean separation of the different layers of notation and meaning.

Characteristic examples for the wide applicabity of TScore are our early animated graphics.
For viewing them, you need a browser which supports SVG graphic rendering together with SMIL animation. (Firefox works fine, microsoft often lousy!-) Soon after the display of one of the graphics below has started, there should be some changes. Otherwise you need different equipment. (scharen0_PARS_p00.svg is an exception, nothing happens until the very end !-)

A small application from 2017 is a project called GraphartScharen, first ideas of which had been developed in the 1980s, together with Dirk Reith.

There is one(1) single source file, from which the following fifteen (15) dynamic graphic files have been generated.
The Java source defining the semantics is GraphartScharen.java.
Each graphic lasts approx. 25 seconds. At its end, a link to the next graphic will appear. When having a first look, it is crucial to do so in ascending numerical order and start with "p00":
scharen0_PARS_p00.svg scharen0_PARS_p01.svg scharen0_PARS_p02.svg scharen0_PARS_p03.svg scharen0_PARS_p04.svg scharen0_PARS_p05.svg scharen0_PARS_p06.svg scharen0_PARS_p07.svg scharen0_PARS_p08.svg scharen0_PARS_p09.svg scharen0_PARS_p10.svg scharen0_PARS_p11.svg scharen0_PARS_p12.svg scharen0_PARS_p13.svg scharen0_PARS_p14.svg

The following scores show the compelling necessity of the TScore approach: The graphics are part of a composition of my colleague Mathias Wittekopf, and he constructed them with interactive tools, by clicking and dragging. THus a readable score never existed and could not exist, until I re-constructed his inputs as a birthday present.

Mathias Wittekopf Vorübergehende Zustände for Voice, Piano and Projection. Movement 1 "Clock Music 1" (Hans Arp):

1. Java source defining the score's semantics
2. Input Score
3. Visual Result

Mathias Wittekopf Vorübergehende Zustände for Voice, Piano and Projection. Movement 8 "Ricercata" (T.S. Eliott):

1. Java source defining the score's semantics
2. Input Score
3. Visual Result

Early simple experiment on abstract moving forms:

1. Java source defining the score's semantics
2. Input Score
3. Visual Result

(All realization by ML)

There is one single Java application for all three examples at http://bandm.eu/metatools/download/MfMain.jar. It requires either the input file as command line parameter or lets it select interactively. FIXME FEHLT !

A "pedagogic" use case: graphic presentation of fugue form disposition. Thematic and counter point material is input by code language, and this is translated into some block graphics. The time axis contains bar numbers.

Example source:

PARS KdF_VII

T          1      2     3    4    5     6     7    8    9    10    11   12   13
VOX sop           Du                    X       3  X                    %
VOX alt                 Cu/2      X           C/2       X
VOX ten    D/2          1       X       D/2>  X    3 X  D/2u       X
VOX bas                           C*2u                                       %

// eof

The result:

And the Java source defining the score's semantics.

The most ambitious field of application is probably CWN in general. For this, we are currently developing an extensive computer model, into which the tscore input is translated. It is currently far from complete, but already quite large, so this section does not come with Java sources, which shall be presented later on their own, with proper documentation.

As a first example: here is a three-part fugue as tscore source and here the LilyPond rendering of the generated source text.

Here you can find the tscore user doc (It is still under construction !-)

Here is a short feature list of tscore, and here dasselbe in Deutsch.

Here a the slides of recent talk about tscore.

References:

made    2024-10-14_10h02   by    lepper   on    happy         
produced with eu.bandm.metatools.d2d    and    XSLT 1.0