Source: Parser/ParserMeasures.js

  1. const ParsedOutputManipulator = require("./ParsedOutputManipulator.js");
  3. const NOTE_STRING = ["c", "c#", "d", "d#", "e", "f", "f#", "g", "g#", "a", "a#", "b"];
  4. /**
  5.  * @class
  6.  * @classdesc Encapsulates functions used to generate an exercise from a collection of measures
  7.  */
  8. class ParserMeasures {
  9.     /**
  10.      * Creates a new ParserMeasures
  11.      * @param {ParsedOutputPackage} parsedOutputObj The main ParsedOutputPackage
  12.      */
  13.     constructor(parsedOutputObj) {
  14.         this.manipulator = new ParsedOutputManipulator(parsedOutputObj);
  15.     }
  17.     /**
  18.      * Converts the duration in seconds of a Note back to the duration in AlphaTex
  19.      * @param {number} durationInSeconds The duration in seconds of the given Note
  20.      * @param {number} currentTempoFactor The current factor based on the tempo
  21.      * @param {Set} beatEffects A set of effects that are modifying the Note
  22.      * @returns {number} The duration as would be noted in AlphaTex
  23.      */
  24.     getDurationFromDurationInSeconds(durationInSeconds, currentTempoFactor, beatEffects) {
  25.         let duration = durationInSeconds;
  26.         if (beatEffects.includes("dotted")) {
  27.             duration /= 1.5;
  28.         }
  29.         duration /= currentTempoFactor;
  30.         duration = 4 / duration;
  31.         return duration;
  32.     }
  34.     /**
  35.      * Creates AlphaTex from a given midi value
  36.      * @param {number} midi The midi value of the Note with -1 as a special value for silence
  37.      * @returns {string} The AlphaTex for that note either "r" for a rest (midi === -1) or the appended string representation of the note and its octave
  38.      * @private
  39.      */
  40.     getTextFromMidi(midi) {
  41.         let text = "";
  42.         if (midi === -1) {
  43.             text = "r";
  44.         } else {
  45.             let octave = Math.floor((midi / 12) - 1);
  46.             let noteIndex = midi % 12;
  47.             let note = NOTE_STRING[noteIndex];
  48.             text = note + octave;
  49.         }
  50.         return text;
  51.     }
  53.     /**
  54.      * @typedef {object} LyricPackage
  55.      * @property {string} tempLyricText The lyric text for this note or empty string
  56.      * @property {number} lyricArrayIndex The latest lyric index into lyricArray
  57.      */
  59.     /**
  60.      * Gets the lyric text for the given Pitch object
  61.      * @param {ParsedOutputPitchPackage} pitch The Pitch object to be analyzed
  62.      * @param {boolean} isDurationExercise If true then this is a duration exercise otherwise if false then it's not
  63.      * @param {string[]} lyricArray The collection of lyrics to pull from
  64.      * @param {number} lyricArrayIndex The latest index into lyricArray
  65.      * @returns {LyricPackage} The lyric text for the pitch if it's not silence and the latest lyric index
  66.      * @private 
  67.      */
  68.     getLyricText(pitch, isDurationExercise, lyricArray, lyricArrayIndex) {
  69.         let tempLyricText;
  70.         let tempLyricIndex = lyricArrayIndex;
  71.         if (isDurationExercise) {
  72.             if (pitch["midiValue"] !== -1) {
  73.                 tempLyricText = "oo";
  74.             } else {
  75.                 tempLyricText = "";
  76.             }
  77.         } else if (pitch["midiValue"] !== -1 && lyricArray !== null) {
  78.             tempLyricText = lyricArray[tempLyricIndex];
  79.             tempLyricIndex++;
  80.         } else {
  81.             tempLyricText = "";
  82.         }
  83.         return {tempLyricText, "lyricArrayIndex":tempLyricIndex};
  84.     }
  86.     /**
  87.      * Creates AlphaTex for the given Pitch
  88.      * @param {ParsedOutputPitchPackage} pitch The Pitch object to be analyzed
  89.      * @param {number} tempoFactor The latest factor based on the tempo
  90.      * @param {boolean} isDurationExercise If true then this is a duration exercise otherwise if false then it's not
  91.      * @returns {string} The generated AlphaTex for the given Pitch
  92.      * @private
  93.      */
  94.     getPitchText(pitch, tempoFactor, isDurationExercise) {
  95.         let pitchText;
  96.         let effectText = "";
  97.         let beatEffectText = "";
  98.         if (pitch["beatEffects"].length > 0) {
  99.             pitch["beatEffects"].forEach((effect) => {
  100.                 if (effect === "tied") {
  101.                     if (effectText.length > 0) {
  102.                         effectText += " ";
  103.                     }
  104.                     effectText += "-";
  105.                 } else if (effect === "dotted") {
  106.                     if (effectText.length > 0) {
  107.                         effectText += " ";
  108.                     }
  109.                     effectText += "d";
  110.                 } else if (effect === "crescendo") {
  111.                     if (beatEffectText.length > 0) {
  112.                         beatEffectText += " ";
  113.                     }
  114.                     beatEffectText += "cre";
  115.                 } else if (effect === "decrescendo") {
  116.                     if (beatEffectText.length > 0) {
  117.                         beatEffectText += " ";
  118.                     }
  119.                     beatEffectText += "dec";
  120.                 }
  121.             });
  122.         }
  124.         let duration = this.getDurationFromDurationInSeconds(pitch["duration"], tempoFactor, pitch["beatEffects"]);
  126.         if (isDurationExercise) {
  127.             if (pitch["midiValue"] === -1) {
  128.                 pitchText = "r";
  129.             } else {
  130.                 pitchText = "c4";
  131.             }
  132.         } else {
  133.             pitchText = this.getTextFromMidi(pitch["midiValue"]);
  134.         }
  136.         if (pitchText === "r") {
  137.             pitchText += "." + duration;
  138.             if (effectText.length > 0 || beatEffectText.length > 0) {
  139.                 pitchText += "{";
  140.                 pitchText += effectText + beatEffectText;
  141.                 pitchText += "}";
  142.             }
  143.         } else {
  144.             if (effectText.length > 0) {
  145.                 pitchText += "{" + effectText + "}";
  146.             }
  147.             pitchText += "." + duration;
  148.             if (beatEffectText.length > 0) {
  149.                 pitchText += "{" + beatEffectText + "}";
  150.             }
  151.         }
  152.         return pitchText;
  153.     }
  155.     /**
  156.      * @typedef {object} ChordTextPackage
  157.      * @property {string} chordText The AlphaTex of the Chord
  158.      * @property {string} lyricText The lyrics that go along with the Chord
  159.      * @property {number} lyricArrayIndex The latest index in the lyricArray
  160.      */
  162.     /**
  163.      * Creates AlphaTex for the given Chord
  164.      * @param {ParsedOutputChordPackage} chord The Chord object to be analyzed
  165.      * @param {number} tempoFactor The latest factor based on the tempo
  166.      * @param {boolean} isDurationExercise If true then this is a duration exercise otherwise if false then it's not
  167.      * @param {string[]} lyricArray The collection of lyrics to pull from
  168.      * @param {number} lyricArrayIndex The latest index into lyricArray
  169.      * @returns {ChordTextPackage} The generated AlphaTex for the Chord and some auxilary information
  170.      * @private
  171.      */
  172.     getChordText(chord, tempoFactor, isDurationExercise, lyricArray, lyricArrayIndex) {
  173.         let chordText = "";
  174.         let lyricText = "";
  175.         let tempLyricIndex = lyricArrayIndex;
  176.         if (Array.isArray(chord["pitches"])) {
  177.             chordText += "( ";
  178.             let duration = null;
  179.             chord["pitches"].forEach((pitch) => {
  180.                 let pitchText = this.getPitchText(pitch, tempoFactor, isDurationExercise);
  181.                 let dotIndex = pitchText.indexOf(".");
  182.                 chordText += pitchText.substring(0, dotIndex) + " ";
  183.                 if (duration === null) {
  184.                     duration = parseInt(pitchText.substring(dotIndex+1, pitchText.length));
  185.                 }
  186.                 let {tempLyricText, lyricArrayIndex} = this.getLyricText(pitch, isDurationExercise, lyricArray, tempLyricIndex);
  187.                 tempLyricIndex = lyricArrayIndex;
  188.                 if (tempLyricText.length > 0) {
  189.                     if (lyricText.length > 0) {
  190.                         lyricText += " ";
  191.                     }
  192.                     lyricText += tempLyricText;
  193.                 }
  194.             });
  195.             chordText += ")";
  196.             chordText += "." + duration;
  197.         } else {
  198.             chordText += this.getPitchText(chord["pitches"], tempoFactor, isDurationExercise) + " ";
  199.             let {tempLyricText, lyricArrayIndex} = this.getLyricText(chord["pitches"], isDurationExercise, lyricArray, tempLyricIndex);
  200.             tempLyricIndex = lyricArrayIndex;
  201.             if (tempLyricText.length > 0) {
  202.                 if (lyricText.length > 0) {
  203.                     lyricText += " ";
  204.                 }
  205.                 lyricText += tempLyricText;
  206.             }
  207.         }
  208.         return {chordText, lyricText, "lyricArrayIndex":tempLyricIndex};
  209.     }
  211.     /**
  212.      * @typedef {object} MeasureTextPackage
  213.      * @property {string} measureText The AlphaTex for the Measure
  214.      * @property {string} lyricsText The lyrics that go along with the Measure
  215.      * @property {number} tempLyricIndex The latest index in the lyricArray
  216.      */
  218.     /**
  219.      * Creates AlphaTex for the given Measure
  220.      * @param {number} measureIndex The index of the Measure to be accessed
  221.      * @param {ParsedOutputStaffPackage} staff The Staff object to be accessed
  222.      * @param {number} currentTempoFactor The latest factor based on the tempo
  223.      * @param {number} measureTempo The tempo of the Measure to be accessed
  224.      * @param {boolean} isDurationExercise If true then this is a duration exercise otherwise if false then it's not
  225.      * @param {string[]} lyricArray The collection of lyrics to pull from
  226.      * @param {number} lyricArrayIndex The latest index into lyricArray
  227.      * @param {number[]} startingTs A 1D two element array representing the current tempo
  228.      * @param {boolean} isLastMeasure If true then this is the last measure otherwise false
  229.      * @returns {MeasureTextPackage} The generated AlphaTex for the Measure and some auxillary data
  230.      * @private
  231.      */
  232.     getMeasureText(measureIndex, staff, currentTempoFactor, measureTempo, isDurationExercise, lyricArray, lyricArrayIndex, startingTs, isLastMeasure) {
  233.         let measureObj = this.manipulator.getMeasure(staff, measureIndex);
  234.         let tempLyricIndex = lyricArrayIndex;
  235.         let measureText = "";
  236.         let lyricsText = "";
  237.         let attributesInt = measureObj["attributesInt"];
  238.         if (attributesInt["tempo"]) {
  239.             measureText += "\\tempo " + attributesInt["tempo"] + "\n";
  240.         }
  241.         if (startingTs !== null) {
  242.             measureText += "\\ts " + startingTs[0] + " " + startingTs[1] + "\n";
  243.         } else if (attributesInt["tsTop"]) {
  244.             measureText += "\\ts " + attributesInt["tsTop"] + " " + attributesInt["tsBottom"] + "\n";
  245.         }
  246.         let tempoFactor = measureTempo === -1 ? currentTempoFactor : 60 / measureTempo;
  248.         if (Array.isArray(measureObj["chords"])) {
  249.             measureObj["chords"].forEach((chord) => {
  250.                 let {chordText, lyricText, lyricArrayIndex} = this.getChordText(chord, tempoFactor, isDurationExercise, lyricArray, tempLyricIndex);
  251.                 tempLyricIndex = lyricArrayIndex;
  252.                 measureText += chordText + " ";
  253.                 if (lyricText.length > 0) {
  254.                     if (lyricsText.length > 0) {
  255.                         lyricsText += " ";
  256.                     }
  257.                 }
  258.                 lyricsText += lyricText;
  259.             });
  260.         } else {
  261.             let {chordText, lyricText, lyricArrayIndex} = this.getChordText(measureObj["chords"], tempoFactor, isDurationExercise, lyricArray, tempLyricIndex);
  262.             tempLyricIndex = lyricArrayIndex;
  263.             measureText += chordText;
  264.             if (lyricText.length > 0) {
  265.                 if (lyricsText.length > 0) {
  266.                     lyricsText += " ";
  267.                 }
  268.             }
  269.             lyricsText += lyricText;
  270.         }
  271.         if (!isLastMeasure) {
  272.             measureText += "|";
  273.         }
  274.         measureText += "\n";
  276.         return {measureText, lyricsText, tempLyricIndex};
  277.     }
  279.     /**
  280.      * @typedef {object} MeasureAlphaTexPackage
  281.      * @property {string} lyricText The lyrics of the provided AlphaTex
  282.      * @property {string} alphaTex The generated AlphaTex
  283.      */
  285.     /**
  286.      * Creates an exercise within the provided measure bounds of the track and staff number specified either a duration exercise or a normal one
  287.      * @param {number[]} measures The start and end of the measure bounds. If null, then get all measures
  288.      * @param {number} trackNumber The number of the Track to be retrieved.
  289.      * @param {number} staffNumber The number of the Staff to be retrieved
  290.      * @param {boolean} isDurationExercise If true then this will generate a duration exercise otherwise if false then it will just copy the Measures
  291.      * @returns {MeasureAlphaTexPackage} If successful, provides the lyrics and generated alphaTex. Otherwise, returns null
  292.      */
  293.     measuresToAlphaTex(measures, trackNumber, staffNumber, isDurationExercise) {
  294.         let trackIndex = trackNumber - 1;
  295.         let staffIndex = staffNumber - 1;
  296.         let track = this.manipulator.getTrack(trackIndex);
  297.         let staff;
  298.         if (track !== null) {
  299.             staff = this.manipulator.getStaff(track, staffIndex);
  300.         }
  301.         if (staff && Array.isArray(measures) && measures.length > 0) {
  302.             // assumes provided array measures is sorted
  303.             let {lyricArray, lyricArrayIndex} = this.manipulator.getLyricArray(staff, measures[0]);
  304.             let lyricText = "";
  305.             let measuresText = "";
  306.             let {measureToTempo, ts} = this.manipulator.visitMeasure(staff);
  308.             // assumes provided array measures is sorted
  309.             let firstMeasureTempo = measureToTempo[measures[0]];
  310.             let startingTempo = firstMeasureTempo === -1 ? this.manipulator.mainObj["tempo"] : firstMeasureTempo;
  311.             let currentTempoFactor = 60 / startingTempo;
  313.             let alphaTex = "\\title \"Exercise t: " + trackNumber + " s: " + staffNumber + " startM: " + measures[0] + " endM: " + measures[1] + "\"\n" +
  314.             "\\tempo " + startingTempo + "\n" +
  315.             ".\n" +
  316.             "\n";
  318.             if (measures.length > 2 && measures[2] === "all") {
  319.                 alphaTex += "\\track \"" + this.manipulator.getTrack(trackIndex).name + "\"\n";
  320.             } else {
  321.                 alphaTex += "\\track \"Exercise\"\n";
  322.             }
  323.             alphaTex += "\\staff {score} \\tuning piano \\instrument acousticgrandpiano \\ks " + staff.keySignature + (staff.clef ? " \\clef " + staff.clef : "") + "\n";
  327.             for (let i = measures[0]; i <= measures[1]; i++) {
  328.                 let measureIndex = i - 1;
  329.                 let startingTs = i !== measures[0] ? null : ts;
  330.                 let isLastMeasure = i === measures[1];
  331.                 let {measureText, lyricsText, tempLyricIndex } = this.getMeasureText(measureIndex, staff, currentTempoFactor, measureToTempo[measureIndex], isDurationExercise, lyricArray, lyricArrayIndex, startingTs, isLastMeasure);
  332.                 lyricArrayIndex = tempLyricIndex;
  333.                 measuresText += measureText;
  334.                 if (lyricsText.length > 0) {
  335.                     if (lyricText.length > 0) {
  336.                         lyricText += " ";
  337.                     }
  338.                     lyricText += lyricsText;
  339.                 }
  340.             }
  342.             if (lyricText.length > 0) {
  343.                 alphaTex += "\\lyrics \"" + lyricText + "\"\n";
  344.             }
  345.             alphaTex += measuresText;
  347.             return {lyricText, alphaTex};
  348.         } else {
  349.             return null;
  350.         }
  351.     }
  353. }
  355. module.exports = ParserMeasures;