Tuning/Microtonal Input - INTERFACE Feature Concept

Hallo everybody,

I first want to say that MuseScore is such an awesome and gorgeous software! A big thank you to all contributors and people behind it for such a nice successful project! I gladly use it for my hobby compositions ;-) .

My interest in MuseScore especially aroused when I discovered it while searching for a free notation program with playback which should be capable of playing and supporting microtones. I was really stunned what kind of professionality of a music notation program is delivered for free with MuseScore2.

And at this point, my idea(s) should link to microtonal composition because I think that microtonal compositions and music could attain an enriching role in modern and future music and has still a lot of potential for use, discovery and support. Some small features for that area would definitely make MuseScore - carefully said - future-oriented.
I've already read about tuning/microtonal plugins and contributions/ideas in the forum (though some plugins are deprecated unfortunately) but I couldn't find something being much enough related to my ideas so that I decided to open this forum thread.
I also want to say that this is just a concept where you decide what you want to support or whether you want to support ideas from it at all. If you think that the actual idea of MuseScore does not interfere enough with these features in order to support it, I should be fine with it but now let me begin to explain the concept ;) ...

--------------

My directive is to keep things simple and modifications feasable and achievable but useful and powerful at the same time so that my ideas concern interface additions, no actual new badass functionality ideas concerning playback, MIDI and so on. In fact, I think, the given microtonal playback functionality and notation possibilities work out already perfectly fine for my concept/future visions and for microtonal compositions.

Furthermore the focus, I want to set here, doesn't point to special accidentals, key signatures, complex notation systems or other symbols and stuff or the playback of it, there are so many other extensive and good ideas concerning this topic (for example: https://musescore.org/en/node/139126 ). I want to commit myself to note input in general. As all people working with microtonal scores in MuseScore might have noticed, the input and use of microtonal scales and notes is very cumbersome in practice since each pitch offset (given in Cent) must be adjusted for each individual note. So I developed some ideas which basically only apply this overhead of work to the program which would be done by the user in an enduring exhausting process of clicking, calculating and typing in the existing interface otherwise. Systematically done by the program, previewing of and adjustments to microtonal compositions in progress would be much easier.

But when support for arbitrary microtones and their playback is integrated, the problem still is the decision of the "correct" or most widely accepted standard notation for any kind of microtones. As I already wanted to indicate I focus on input, not on difficult notation systems, so that my idea for an immediate general solution for easy reading/recognition of microtones would be to use an option (checkbox/toggle button) to automatically colour notes depending on their tuning/pitch (while still keeping the old colour property of notes unchanged for the case that the option will be unchecked again). Details further below...

-----------------

General ideas:

(an overview - more detailed explanations follow afterwards - naming in this concept is not necessarily mandatory but avails a better understanding)

• an adjustable up/down-pase for notes ("shifting" of selected notes when arrow-keys up and down are pressed), automatically aligned to a currently set EDO-scale for input (-> base support for input aligned to n-EDO scales, i.e. the pase up/down will put the note to the next tone available in the used input scale for tones)
• additional interface fields for note input (to display in the "note input ribbon"):
• EDO-scale (natural number field, by default 12)
• scale offset (floating point field, 0 to 1200 Cent) which should be the reference point (base note) for tones which is located within one octave from the scale (some of the new note properties I conceived relate to this point later)
• checkbox/toggle button option for microtone-specific note colouring (ignores but doesn't modify the notes' colour property) to enable a basic standard microtonal visualization
• two additional sections in a note's property window called "Note Tuning" and "Remembered Input Scale" with these new fields:
  • used octave (integer field)
  • displayed unit (list with entries "ratio", Hz" and "Cent") -> sets the interpretation for fields that are related to a note's pitch
  • offset within octave (floating point number field) -> specifies the pitch offset of a selected note relative to the current octave's base note (identifies the exact position of the selected note together with "used octave")
  • 12TET-based tuning (floating point number) -> a similar field to the field "tuning" from current MuseScore versions which shows (and allows manipulation of) the pitch based on a "dodecaphonic note" (a "12TET note")
  • scale index (natural number, 1 to EDO_scale_length) -> displays the index of the note's pitch within the currently used EDO-scale from the input settings ribbon; better start with at index 1 instead of 0, this is common practice in music theory, even for intervals.
    (the value is calculated this way in Cent:

    (current_pitch - octave_base)/1200 * scale_size

    with truncated decimal fraction (needed if the current note's pitch is not included in scale) => this field contains the note index of the first note in scale prior or equal to current note's pitch).

  • remembered scale size/scale offset (a copy of the input scale settings) -> saves the input scale from the "input settings ribbon" in a note's properties; it concerns the input scale which was set when the last modification (i.e. a note shift with up/down arrows, other keys or mouse) of the currently selected tone was made; a corner case (see far below) happens when this copy is changed by the user manually in the inspector window)
  • absolute pitch (floating point number) -> can be displayed in Hz or in Cent (interpreted as offset from lowest possible (supported) pitch)

NOTE that EDO support still doesn't mean arbitrary microtonal scale support with varying rational note distances between adjacent notes in scale or TET (equal temperament) scales based on non-octave-intervals. If you guys are very ambitious and want to have quite flexible features you could add an additional text field in the "input settings ribbon" used for note input alignment to general microtonal scales besides the "EDO-scale" field in the note input ribbon. This additional field would contain a scala file name and could have a button which allows to browse for scala files on the computer and MuseScore would align note properties and the individual up/down pase of each note to the scale described by the scala file. This way, a pure major scale or minor scale could be imported and all notes would be aligned to this scale as a special case. Read more about the .scl file format:
//www.huygens-fokker.org/scala/scl_format.html

---------------

Detailed Description:

(I just want to indicate that my concept is supported with an attached image at the end to enhance the comprehension with visualization.)

EDO-Scale

At first something about the input scale settings. It begins with the EDO-Scale ("Equal Devisions of Octave") number field which determines the number of divisions per octave, used for the input of notes. The actual note input functionality should not need to be revolutionized (neither mouse input nor key input). The same standard 12TET-notes (here: 12TET (twelve-tone equal temperment) = 12EDO) are detected as input notes (the completely same way as before) but now are translated in the last phase to the nearest microtonal tone of the currently set input scale. (Whether the nearest higher(+)/lower(-) scale-note is searched for is a decision made by the used integer sign of option "Scale-based Tuning" below. That only one direction is used to look for the nearest note is thought to implicate, that the 12TET-note (representing the microtone) mustn't change its position in its staff after tuning adjustment ("translation") to a microtone from the set input scale.) The typical 12TET accidentals (# and b) have still the same functionality as before with 12TET-only support. Given a usual 12TET scale signature with multiple accidentals at the beginning of a staff line, it still infers the accidentals for tones that do not carry accidentals explicitly. It also means that only a subset of 12TET notes is recognized during the note input by mouse before being translated to the proper microtone. Tones can be adjusted by using up/down arrow keys or with the note property fields.

INPUT SCALE - EDO-Scale Number Field
This field affects, to what scale/pitch the notes will be aligned when inserted. The value is interpreted as the number of equal divisions per octave to be set for the current input. When a usual 12-TET note is inserted, it will be automatically translated to the nearest note from this active input EDO-Scale. And the note pase used for modifications ("shifts") with up/down arrows (for example) is determined by this input scale too. When a note is selected and up/down is pressed, the note will become the next/previous note in the scale.
The idea behind this feature is only based on supplying interface-facilitating mathematics/calculations, i.e. linear functions when calculated in unit Cent. The distance (pase) between two notes of an EDO scale would be: 1200/#inputValue [Cent].
And when a microtone's pitch would reach an offset (distance) of slightly over 100 Cent away from a currently displayed 12TET note in score, the next/previous 12TET-note is used to display/represent that microtone. This rule does not apply when the offset value has been specified manually by the user in the note tuning property fields within the inspector window. While the program generates only values between -100 and 100 for option "12TET-based Tuning", the user may choose a value between -200 and 200. This way, the note (used to represent a microtone in score) is not changed but the represented microtone can reach pitches which would be displayed by another 12TET-note in score when set automatically by the programm.

INPUT SCALE - Scale Offset
This floating point field determines where the input scale should begin between C and C of the next octave [originally conceived as A instead of C but rejected due to the convenient scale signature of C Major which is free of accidentals]. Slightly different values (set for this option) will lead to insertion of slightly differently tuned notes. It must be asserted that a note always has a specific offset to the scale's base tone which is a multiple of the EDO-scale's pase between adjacent notes. This option's value also affects the note property which displays the note's index in the scale.

INPUT SCALE - Scala File
(This feature can be implemented optionally by ambitious programmers. It would be very cool and would enable flexible microtonal compositions but, at first, general EDO-scale support is much more important in my opinion.)
This text field shows the currently used scale (imported as scala file, .scl) with the possibility to browse for files on the PC. When a scala file is selected, it's content is parsed and input scale information is generated ready to be used for note tuning alignment. It would also require significant additional data structure effort - not only because of the data representation of arbitrary scales but also because for each effectively used Scala file, a local list of already included scales may be saved to comprimize the size of the remembered scale property for each note. With a local list of used scales for each score, the remembered scale property of each note only needs to save an index to that list instead of the much more complex input scale data structure (because the data structure for the input scale would need to be capable of representing any arbitrary scales and tone distances, theoretically).

Tone Colouring:
Generally, microtones still should be placed like 12-TET notes on (and between) lines of a staff but different pitches on the same line are distinguished by different colour (and with # or b). When this option is turned on, the colour is displayed independently of the note colour property which remains unmodified.
Base tone of a scale: black.
Any other microtone is coloured based on the offset from the 12-TET note displayed as representative (which also can include sharp notes and flat notes like C# and Db). The idea is: the 12-TET-based tuning range [0, 100[ (i.e. from 0 (inclusive) to 100 (exclusive)) should be mapped linearly to the colour with hue in range [0, 360[ and can be repeatedly mapped for multiples of 100 Cent. Tuning of 0 Cent would be mapped to colour with hue 360, tuning of about 100 Cent would be mapped to a hue of about 0 (this is shown by the attached image, a reverse mapping would be possible too). I know, that unlike the (theoretical) pitch of microtones, displayed colour can only have a discrete hue (natural number). But I guess, the colour idea is sufficient enough to visually differentiate the smallest reasonable microtone difference that can be noticed accoustically.

NOTE TUNING - Used Octave
Determines with a (signed) integer number, in which octave the current tone is located. The one-line octave (lower half octave used with the treble clef) is indicated by 0.
Modifying this field leads to an octavation of the note (or conversely, octavating notes leads to a modification of this value).

NOTE TUNING - Displayed Unit
Is included in the concept to enable more flexibility to work with displayed information. Changing the selection of this list value changes the interpretation of the octave offset, absolute pitch or 12TET-based tuning field for example. The units "ratio" and "Cent" both work only with reference points (they represent a unit for distances between pitches) so that there must be specified a fixed lowest supported tone to be used as reference point to display the "Absolute Pitch" of a note. "Cent" is a logarithmic unit to handle pitch distances linearly. "Ratio" is a non-logarithmic unit which displays the frequency ratio of the compared pitches and "Hertz" displays the exact frequency (distance) of tones. For the illustration I assumed that the lowest supported tone is exactly 5 octaves under c1 so that c1 corresponds 5 * 1200 Cent which would be a ratio of 2^5/1 = 32. Changing this value does neither affect the tuning/pitch nor the notation of the note in score so it is not needed to be remembered when set.

NOTE TUNING - Offset within Octave
Is used together with "Used Octave" to determine the exact pitch/position of a note. Modifying this field's value can move the note up and down. For this purpose, this option determines the exact distance to the octave's base tone. A floating point value can be set.

NOTE TUNING - 12TET-based Tuning
This option/setting visually similes the already existing tuning option. The value range should work the same way as the current MuseScore Tuning option already does, allowing values in range -200 to 200 Cent. The value of this option will always correlate to .../ is determined ... by the note's exact pitch but can be changed by hand like other options and allows manipulation to the selected note's pitch. Otherwise (when not changed by hand) the value is attuned steadily to be consistent with the note's exact pitch (most often the scale-included note's pitch) even after the exact pitch of the note was modified (shifted by up/down arrow keys). This alignment can be done by using either only positive or only negative values whose choice can be bound to the specificly set input scale at a time. The idea behind the choice of the generated sign of the number is motivated at the end of this concept based on simple music theory.
With "Absolute Pitch" this option belongs to those who avail likely more for an information purpose than a manipulation purpose.

NOTE TUNING - Absolute Pitch
The idea behind this option is to have one possibility to set the exact position/pitch of a tone by only one number (any of all supported pitches). The entered value should support the interpretation in Cent or Hertz. Since Cent is a logarithmic unit, it always needs a reference point which would be the lowest supported pitch denoted to by value 0. I don't know what note it actually would be nor its value in Hertz but I guess it could be interesting and maybe useful to play with the absolute pitch of a note (especially for ratio distances to set which allows mathematics to be used/analyzed more specificly for composition). After all, the option is just meant to be a mathematical feature to simplify work.

Note Tuning with Scale-specific Properties

In the following I explain two further note tuning options and afterwards the property fields to display information of the remembered (input) scale of a selected note (for the basic idea behind remembering scales see the introduction to "Remembered Input Scale"). As with the options above, the value of each option here is set automatically but can be modified/set manually as well. If one value is changed manually, the note's new pitch is calculated first and - based on the result - all other yet unchanged options (properties) are updated automatically corresponding to the new pitch.

NOTE TUNING - Scale Index
This option is some kind of link between the note tuning section and the dedicated section for the remembered input scale. In dependency of the currently remembered scale, this value is the mapping result of the note pitch to an index value between 1 and the total number of notes of the remembered scale. This option should tell the user the place of a selected note in the remembered scale (some kind of information purpose which also can be played with). It can happen (corner case) that a selected note is not included in its remembered scale but the index is a natural number corresponding the next smaller or bigger note of the remembered scale. (Whether it is the next smaller or the next bigger note is only dependent on the sign of "Scale-based Tuning".)

NOTE TUNING - Scale-based Tuning
Similar to "12TET-based Tuning" but extends its functionality to work with any scale and rather equals the yet existing Tuning functionality in MuseScore so that this option is also conceived for backwards compatibility and to avoid more confusion to well-adapted users, however: for a 12TET scale this option will only allow values from -100 to 100 instead of -200 and 200 as it can be read and motivated in the continuing description.
In contrast to "12TET-based Tuning", this value is never changed when a note is modified by up/down arrow keys, i.e. this value stays constant when a note is shifted and continously adds the given value as a kind of additional offset to the pitch of the selected note.
This option is supposed to determine a distance of the selected note (most probably not included in scale) to the next included note in the remembered (input) scale. Logically, when the selected note designates a tone included in the remembered scale, this option could contain "0,00" as value or the exact distance between two notes of the scale. The floating point value range of the related number field is dynamically limited to the maximum distance between two adjacent notes in the remembered scale of the selected note.
[The previous but now deprecated idea for the value limits was following: When arbitrary scales are supported, it could be even two different distances (lower and upper distance) as negative/positive value limit where the distances are calculated in a way based on the current "Scale Index" value. The Scale Index value determines three notes (-> the scale note owning the index and both adjacent notes included in scale) whose distances are used as current limits for the number field.]
More generally, this option should display an additional user-specified offset off the remembered scale for a selected tone. The effect on the pitch of this option equals the effect of option "Remembered Scale Offset" but without affecting the remembered scale information of any selected specific note (which is useful for single notes slightly varying from a generally used scale in a passage of the scope because of a specific compositional reason).

Remembered Input Scale

Designates a specific EDO-scale which was remembered to be lastly used for the selected note. When a note is selected, the current input scale from the input settings ribbon is updated with this scale information that was saved/remembered to be the last scale used as alignment for the just selected tone. This helps to cleanly separate different parts of the score and to avoid manipulation mistakes (accidentally manipulating tones with a different input scale setting than originally planned which happens after having edited a part with other scale and not changing back the input scale setting).

REMEMBERED INPUT SCALE - Remembered Scale Size
A tiny backup of the size information from the input scale settings which was created at the time when the selected note was shifted or entered with keyboard/mouse. (I.e. a scale "S" is always saved as remembered scale for a note "N" when the note "N" was aligned to the scale "S" (after "S" was effectivly used) which means the note remembers the scale information used for the latest translation/alignment.)

REMEMBERED INPUT SCALE - Remembered Scale Offset
This number field displays the remembered scale's offset of the selected note - it is a floating point value also used for the calculation of other property values. This field is related to the "Remembered Scale Size" property and the "Scale Offset" setting for input scales in the input settings ribbon. Like "Remembered Scale Size" it is a saved copy of one part of the input scale's settings which will be used to update to the input scale's offset again when the note is selected. The current input scale's offset is always remembered for the selected note only when the selected note's pitch is modified (shifted). This option can be manipulated manually of course as well.

REMEMBERED INPUT SCALE - Remembered Scale (.SCL)
An optional property which is only needed when Scala support should be implemented. This option is similar to "Remembered Scale Size" but generalized to support any scale, not only EDO. It should be a list property containing entries for every effectively remembered scale in the total score. Each entry displays the name of the scale (without .SCL extension) being represented by the entry. Be careful by changing the entry manually since changing it would potentially remove the previously remembered Scale from the list (see Corner Cases below).

Design:

For the visual aspects of the interface, I also attached a faked image showing how I imagine the look of my feature ideas.
The blue-marked area in the input settings ribbon part shows the additional input interface fields, mentioned at the beginning. The number field right to the double-arrow symbol should denote the EDO "size" of the scale's octave interpreted as number of equal divisions per octave used for input alignment. Underneath, the number field determines the scale base's offset from the standard base note "C". The third component in that area is the toggle button to switch on/off the colouring of notes. The dirty-yellow-marked area contains the optional idea with scala files in the NOTE above. The selected button in the image left to the text field should denote the browse button.
Other panes in the image show my idea how the new note properties in the inspector window for selected notes could look like and how I imagine the note colouring and microtone scale signature to look like in the score.

---------------

Corner Cases - what happens when:

• ...the remembered EDO-scale is changed manually for an existing note? => Note keeps its pitch/position but the property fields will change.
• ...a selected note is not included in the remembered scale, what scale-related properties should be displayed in the tuning block? => Either some kind of "no property" symbol or the property of the nearest tone in scale.
• ...a note should be coloured having a "12TET-based Tuning" value out of range [0,100[ ? => It could alter the lightness/saturation of the colour; -200 to -100, -100 to 0 and 100 to 200 create the same colour (hue) like 0 to 100.
• ...multiple notes are selected and their pitch is modified, which note remembers the input scale settings and how will each tone be shifted (what "pase" is used)? => There are several possibilities to solve this question which can be divided even in independent subproblems where the final approach can be taken as it is prefered by the supervisor:
  • input scale update/adjustment:
    1. current input scale is not changed with a selection of multiple notes and is updated with the remembered scale of the 1st selected note
    2. current input scale is updated with the remembered scale which the majority of selected notes has in common
    3. current input scale is updated with the remembered scale of the lastly selected note
    4. current input scale corresponds one of the first three options but cannot be altered manually during the selection
    5. behaviour is undefined (nothing happens) when remembered scale information is not equal among all selected notes
  • remembered input scale:
    1. all selected notes will remember the current input scale (which was just updated by the selection or altered manually by the user)
    2. all notes will keep their own remembered scale without changes, independent of current input scale
    3. all notes that have the same remembered input scale as the one used for the automatical input scale update will remember the current input scale
    4. bevhiour is undefined (nothing happens) when the remembered scale is not equal among all selected notes
  • tone pase/shifting behaviour:
    1. each tone is shifted aligned to the currently set input scale
    2. each tone is shifted aligned to its own remembered input scale
    3. each tone is shifted by the default input scale (12TET) (not recommended at all, unexpected behaviour, tosses away chances for a useful functionality)
    4. behaviour is undefined (no shift/pase is possible) when the remembered scale is not equal among all selected notes
• ...an input scale was used only once (and was saved in the properties of one note) but was replaced afterwards by another scale so that the previously remembered scale is not remembered by any tone in the score anymore? => When a list management of scales is needed due to Scala support with more complex data representation of scales, this forgotten scale (object) must be deleted and removed from the score's list of altogether used scales. When no list management is in need, it doesn't matter, since each scale is only a primitive number (from the EDO-scale number field in the input settings ribbon) and there are no additional scale objects with additional data structure.

------------------

Desirable but incomplete/missing Ideas with Suggestions

• easy input of any random (arbitrary) notes of the current input scale, not only nearest notes to 12TET-notes
• key shortcuts to set tones of a scale which are not any of the nearest tones to a 12TET note
• what happens with the new input scale fields when arbitrary scales are supported and a Scala file is used which doesn't correspond to an EDO scale? => The natural number field for the EDO scale size in the "input settings ribbon" could be greyed out (or marked in another) and keep the value which it displayed lastly. But the field must still be usable somehow. There must be a way to set a new EDO scale setting (when required) with this field so that they can't be really disabled. Maybe it can be achieved with a toggle switch that switches between the usage of the EDO scale size field or the Scala file field in the input settings ribbon.
• microtone scale signatures that can be generated and added to the score: a notation is needed to denote a microtone scale as it can be done with 12TET "scales" via accidentals at the beginning of a staff (C Major, G Major, D Major ...)
  (maybe the scale can be denoted by its name (with fixed standard properties like font: Franklin Gothic Demi, size: 10p) - for example "23EDO" or the scala file name without extension - centered in the same vertical height where the scale's base tone is represented as 12TET note)
• a tuning standard - should scale tones (not 12TET) be represented with positive 12TET-based tuning or with negative 12TET-based tuning values?
  (Suggestion: make decision similar to the existing accidental system in 12TET. The scale base's offset correlates to a specific 12TET signature consisting of accidentals. In particular, the scale base's offset is the pitch of the base tone of a scale, so that D Major is a 12TET scale with base offset 2 * 100 Cent. This way, the base offset of the scale could determine the accidentals of the scale's signature and the kind of theoretical accidentals would determine whether negative or positive 12TET-based tuning values are used. If the theoretical 12TET scale signature would consist of #s -> positive values are used in option "12TET-based Tuning" for the translation; when consisting of bs -> negative values. If a scale signature is explicitly given (with only #s or bs) then the input scale's base offset is ignored and the decision is met depending on the explicit signature.)
• should there be an optional input mode dedicated to enabling microtone/scale-directed input??

-------------------

Here my concept ends. I hope it can prove to be useful for microtonal input support in MuseScore but don't stress yourself with fullfilling/implementing/accepting this concept. If it doesn't fit to the requirements/needs of MuseScore imagined by the community or developers you don't need to further care about it. This concept is just for the case you're interested in enhancing/facilitating microtonal input which could improve microtonal compositions really a lot.

So, still have a nice day.
Regards from Germany!