jm.music.data

## Class Note

- java.lang.Object
- - jm.music.data.Note

- All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable
  Direct Known Subclasses:
    Rest

      public class Note
      extends java.lang.Object
      implements java.lang.Cloneable, java.io.Serializable

  The Note class is representative of notes in standard western music notation. It contains data relavent to music note information such as time, duration and pitch. Notes get contained in Phrase objects. Like in tradtional music notation (CPN) notes get played one after the other in the order in which they are added to the Phrase.
  !IMPORTANT: notes with a pitch of the minimum integer are rests, those between 0 <> 127 are exactly the same as normal sounding notes numbered like the MIDI specification. Notes with a pitch specified as a double value, e.g., 440.0, are frequency values for the note pitch. In general, note pitch refers to the chromatic key number (as per MIDI) as an int and the note frequency refer to the value in hertz as a double value.
  Notes can be added to a phrase like this...

           Phrase phrase = new Phrase(0.0);
           Note note = new Note(C4, CROTCHET, MF);
           phrase.addNote(note);

  The note also has the option to create notes with reasonable default values. This allows a user who is not interested in any performance details to work with notes solely using pitch value and rythmValue like this....

           Note note = new Note(C4, CROTCHET);

  The final option for building a note also includes the dynamic parameter for minimal performace information.

           Note note = new Note(C4, CROTCHET, F);

  Comments about the offset parameter: The intention of offset was to allow for 'feel' in score playback. For example, a snare drum might be played slightly ahead or behind the beat, or a sound with a slow attack might need to be triggered early in order to sound in time with other parts. With this in mind, offset should have no influence on rhythmValue or duration calculations within the jMusic data structure, only when translated to another format (eg MIDI). In your example (offset 0.1, duration 0.8, and rv 1.0) the rendering (MIDI or other that does not support the offset concept) should consider the start time of the note 0.1 bpm later than 'normal' but the duration of the note will be 0.8 bpm from that offset start time. The next note should start 1.0 bpm after the 'normal' startTime (ignoring offset). This allows for offset to be used in cases where performance of music varies from beat to beat, eg., the downbeat is anticipated slightly. In extreme cases this could cause overlapping notes in MIDI translation which need to be 'handled' but we consider this a weakness of the MIDI data specification rather than a problem for jMusic : ) In short, think of offset as "A displacement from the normal start time of a note that allows performance interpretation without distorting the score for compositional or analysis purposes." ---------------
  See Also:
    `Phrase`, Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static java.lang.String` | `A`
    `static java.lang.String` | `A_FLAT`
    `static java.lang.String` | `A_SHARP`
    `static int` | `AMP_ENV` Specified envelope break point value indexes
    `static java.lang.String` | `B`
    `static java.lang.String` | `B_FLAT`
    `static java.lang.String` | `C` string constants for keys on the keyboard
    `static java.lang.String` | `C_SHARP`
    `static java.lang.String` | `D`
    `static java.lang.String` | `D_SHARP`
    `static double` | `DEFAULT_ARTICULATION` Default articulation.
    `static double` | `DEFAULT_DURATION` default duration
    `static double` | `DEFAULT_DURATION_MULTIPLIER` default duration multiplier
    `static int` | `DEFAULT_DYNAMIC` default dynamic
    `static double` | `DEFAULT_OFFSET` default offset value
    `static double` | `DEFAULT_PAN` default pan value
    `static int` | `DEFAULT_PITCH` default pitch value
    `static double` | `DEFAULT_RHYTHM_VALUE` default rhythmValue
    `static double` | `DEFAULT_SAMPLE_START_TIME` The number of seconds into a sample to begin reading data
    `static java.lang.String` | `E`
    `static java.lang.String` | `E_FLAT`
    `static java.lang.String` | `F`
    `static java.lang.String` | `F_SHARP`
    `static int` | `FILTER_ENV`
    `static boolean` | `FREQUENCY` Pitch type flag - indicates that pitch should be a frequency in hertz.
    `static java.lang.String` | `G`
    `static java.lang.String` | `G_SHARP`
    `static double` | `MAX_DURATION` The largest value for a note's duration.
    `static int` | `MAX_DYNAMIC` The largest value for a dynamic.
    `static double` | `MAX_MIDI_PITCH` The largest value for a pitch.
    `static double` | `MAX_PAN` The largest pan value for a note.
    `static int` | `MAX_PITCH` The largest value for a pitch.
    `static double` | `MAX_RHYTHM_VALUE` The largest value for a rhythValue.
    `static boolean` | `MIDI_PITCH` Pitch type flag - indicates that pitch should be MIDI note number.
    `static double` | `MIN_DURATION` The smallest value for a note's duration.
    `static int` | `MIN_DYNAMIC` The smallest value for a dynamic.
    `static double` | `MIN_FREQUENCY` The smallest value for a frequency.
    `static double` | `MIN_PAN` The smallest pan value for a note.
    `static int` | `MIN_PITCH` The smallest value for a pitch.
    `static double` | `MIN_RHYTHM_VALUE` The smallest value for a rhythmValue.
    `static int` | `PAN_ENV`
    `static int` | `PITCH_ENV`
    `static int` | `REST` The pitch value which indicates a rest.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Note()` Default constructor assigns null values to all note attributes
    `Note(double frequency, double rhythmValue)` Assigns frequency and rhythmic values to the note object upon creation
    `Note(double frequency, double rhythmValue, int dynamic)` Assigns frequency and rhythmic values to the note object upon creation
    `Note(double frequency, double rhythmValue, int dynamic, double pan)` Assigns frequency and rhythmic values to the note object upon creation
    `Note(int pitch, double rhythmValue)` Assigns pitch and rhythmic values to the note object upon creation Other values (e.g.
    `Note(int pitch, double rhythmValue, int dynamic)` Assigns pitch and rhythmic values to the note object upon creation Other values (e.g.
    `Note(int pitch, double rhythmValue, int dynamic, double pan)` Assigns pitch and rhythmic values to the note object upon creation Other values (e.g.
    `Note(java.lang.String note)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Note` | `copy()` Returns a copy of this note
    `boolean` | `equals(Note note)`
    `static int` | `freqToMidiPitch(double freq)` Convert a frequency into a MIDI note pitch.
    `double[]` | `getBreakPoints(int index)` Retrieve the break point envelope values.
    `double` | `getDuration()` Return note duration.
    `int` | `getDynamic()` Retrieve notes dynamic
    `double` | `getFrequency()` Retrieve the note's pitch as a frequency
    `Phrase` | `getMyPhrase()` Return a reference to the phrase containing this note
    `java.lang.String` | `getNote()` gets the string representation for a note for a given MIDI pitch (0-127)
    `static java.lang.String` | `getNote(int pitch)` gets the string representation for a note for a given MIDI pitch (0-127)
    `double` | `getOffset()` Return note offset.
    `double` | `getPan()` Retrieves note's pan.
    `int` | `getPitch()` Retrieve the note's pitch as an integer.
    `boolean` | `getPitchType()` Retrieve note's pitch type
    `int` | `getPitchValue()` returns the pitches for the middle scale(default) on a keyboard
    `double` | `getRhythmValue()` Retrieve note's rhythmValue
    `double` | `getSampleStartTime()` Return note sampleStartTime
    `boolean` | `isFlat()` tells whether the note is a sharp or not by using its string value
    `boolean` | `isNatural()` tells whether the note is natural or not
    `boolean` | `isRest()` Check if the note is a rest or a pitched note.
    `boolean` | `isScale(int[] scale)` Checks if the note is within a particular scale There are a number of scale constants specified in the JMC which can be used with this method, these include MAJOR_SCALE, MINOR_SCALE, and PENTATONIC_SCALE
    `boolean` | `isSharp()` tells whether the note is a sharp or not
    `static double` | `midiPitchToFreq(int midiPitch)` Calculate the frequency in hertz of a MIDI note pitch.
    `Note` | `nextNote(int[] scale)` gives the next note in the scale For example, if inputting a D note for a DMinor scale, the next note returned is an E if inputing a Bb for a C
    `boolean` | `sameDuration(Note note)`
    `boolean` | `samePitch(Note note)`
    `void` | `setBreakPoints(int index, double[] points)` Specify the values for a break point envelope.
    `void` | `setDuration(double duration)` Set notes duration.
    `void` | `setDynamic(int dynamic)` Assign notes dynamic
    `void` | `setFrequency(double freq)` Assign notes pitch as a frequency.
    `void` | `setLength(double newLength)` Change both the rhythmValue and duration of a note in the one step.
    `void` | `setMyPhrase(Phrase phr)` Sets a reference to the phrase that contains this note
    `void` | `setOffset(double offset)` Set notes offset.
    `void` | `setPan(double pan)` Assign notes pan.
    `void` | `setPitch(int pitch)` Assign notes pitch.
    `void` | `setPitchType(boolean newType)` Specifies the note's pitch type.
    `void` | `setRhythmValue(double rhythmValue)` Assign notes rhythmValue
    `void` | `setRhythmValue(double rv, boolean factorDuration)` Sets the rhythmValue, and optionally change the duration at the same time.
    `void` | `setSampleStartTime(double sampleStartTime)` Set notes sampleStartTime
    `java.lang.String` | `toString()` Collects a string of the notes attributes

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### DEFAULT_PITCH

          public static final int DEFAULT_PITCH

      default pitch value
      See Also:
        Constant Field Values

    - #### DEFAULT_RHYTHM_VALUE

          public static final double DEFAULT_RHYTHM_VALUE

      default rhythmValue
      See Also:
        Constant Field Values

    - #### DEFAULT_DYNAMIC

          public static final int DEFAULT_DYNAMIC

      default dynamic
      See Also:
        Constant Field Values

    - #### DEFAULT_PAN

          public static final double DEFAULT_PAN

      default pan value
      See Also:
        Constant Field Values

    - #### DEFAULT_DURATION_MULTIPLIER

          public static final double DEFAULT_DURATION_MULTIPLIER

      default duration multiplier
      See Also:
        Constant Field Values

    - #### DEFAULT_ARTICULATION

          public static final double DEFAULT_ARTICULATION

      Default articulation. This field is meant to replace DEFAULT_DURATION_MULTIPLIER.
      See Also:
        Constant Field Values

    - #### DEFAULT_DURATION

          public static final double DEFAULT_DURATION

      default duration
      See Also:
        Constant Field Values

    - #### DEFAULT_OFFSET

          public static final double DEFAULT_OFFSET

      default offset value
      See Also:
        Constant Field Values

    - #### DEFAULT_SAMPLE_START_TIME

          public static final double DEFAULT_SAMPLE_START_TIME

      The number of seconds into a sample to begin reading data
      See Also:
        Constant Field Values

    - #### MIN_PITCH

          public static final int MIN_PITCH

      The smallest value for a pitch.
      See Also:
        Constant Field Values

    - #### MIN_FREQUENCY

          public static final double MIN_FREQUENCY

      The smallest value for a frequency.
      See Also:
        Constant Field Values

    - #### MAX_MIDI_PITCH

          public static final double MAX_MIDI_PITCH

      The largest value for a pitch.
      See Also:
        Constant Field Values

    - #### MAX_PITCH

          public static final int MAX_PITCH

      The largest value for a pitch.
      See Also:
        Constant Field Values

    - #### MIN_RHYTHM_VALUE

          public static final double MIN_RHYTHM_VALUE

      The smallest value for a rhythmValue.
      See Also:
        Constant Field Values

    - #### MAX_RHYTHM_VALUE

          public static final double MAX_RHYTHM_VALUE

      The largest value for a rhythValue.
      See Also:
        Constant Field Values

    - #### MIN_DYNAMIC

          public static final int MIN_DYNAMIC

      The smallest value for a dynamic.
      See Also:
        Constant Field Values

    - #### MAX_DYNAMIC

          public static final int MAX_DYNAMIC

      The largest value for a dynamic.
      See Also:
        Constant Field Values

    - #### MIN_PAN

          public static final double MIN_PAN

      The smallest pan value for a note.
      See Also:
        Constant Field Values

    - #### MAX_PAN

          public static final double MAX_PAN

      The largest pan value for a note.
      See Also:
        Constant Field Values

    - #### MIN_DURATION

          public static final double MIN_DURATION

      The smallest value for a note's duration.
      See Also:
        Constant Field Values

    - #### MAX_DURATION

          public static final double MAX_DURATION

      The largest value for a note's duration.
      See Also:
        Constant Field Values

    - #### REST

          public static final int REST

      The pitch value which indicates a rest.
      See Also:
        Constant Field Values

    - #### FREQUENCY

          public static final boolean FREQUENCY

      Pitch type flag - indicates that pitch should be a frequency in hertz.
      See Also:
        Constant Field Values

    - #### MIDI_PITCH

          public static final boolean MIDI_PITCH

      Pitch type flag - indicates that pitch should be MIDI note number.
      See Also:
        Constant Field Values

    - #### AMP_ENV

          public static final int AMP_ENV

      Specified envelope break point value indexes
      See Also:
        Constant Field Values

    - #### PITCH_ENV

          public static final int PITCH_ENV

      See Also:
        Constant Field Values

    - #### FILTER_ENV

          public static final int FILTER_ENV

      See Also:
        Constant Field Values

    - #### PAN_ENV

          public static final int PAN_ENV

      See Also:
        Constant Field Values

    - #### C

          public static final java.lang.String C

      string constants for keys on the keyboard
      See Also:
        Constant Field Values

    - #### G

          public static final java.lang.String G

      See Also:
        Constant Field Values

    - #### D

          public static final java.lang.String D

      See Also:
        Constant Field Values

    - #### A

          public static final java.lang.String A

      See Also:
        Constant Field Values

    - #### E

          public static final java.lang.String E

      See Also:
        Constant Field Values

    - #### B

          public static final java.lang.String B

      See Also:
        Constant Field Values

    - #### F_SHARP

          public static final java.lang.String F_SHARP

      See Also:
        Constant Field Values

    - #### C_SHARP

          public static final java.lang.String C_SHARP

      See Also:
        Constant Field Values

    - #### G_SHARP

          public static final java.lang.String G_SHARP

      See Also:
        Constant Field Values

    - #### D_SHARP

          public static final java.lang.String D_SHARP

      See Also:
        Constant Field Values

    - #### A_SHARP

          public static final java.lang.String A_SHARP

      See Also:
        Constant Field Values

    - #### A_FLAT

          public static final java.lang.String A_FLAT

      See Also:
        Constant Field Values

    - #### E_FLAT

          public static final java.lang.String E_FLAT

      See Also:
        Constant Field Values

    - #### B_FLAT

          public static final java.lang.String B_FLAT

      See Also:
        Constant Field Values

    - #### F

          public static final java.lang.String F

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### Note

          public Note()

      Default constructor assigns null values to all note attributes

    - #### Note

          public Note(int pitch,
              double rhythmValue)

      Assigns pitch and rhythmic values to the note object upon creation Other values (e.g. dynamic) are given reasonable defaults
      Parameters:
        `MIDI` - pitch range is 0-127 (middle c = 60): Constant values representing pitch values can be found in JMC
        `rhythmValue` - 0.5 = quaver: constant values representing most duration types can be found in JMC

    - #### Note

          public Note(int pitch,
              double rhythmValue,
              int dynamic)

      Assigns pitch and rhythmic values to the note object upon creation Other values (e.g. dynamic) and given reasonable defaults
      Parameters:
        `MIDI` - pitch range is 0-127 (middle c = 60): Constant values representing pitch values can be found in JMC
        `rhythmValue` - 0.5 = quaver: constant values representing most duration types can be found in JMC
        `dynamic` - range is 0-127 (0 = off; 127 = loud): Constant values representing some basic dynamic types can be found in JMC

    - #### Note

          public Note(int pitch,
              double rhythmValue,
              int dynamic,
              double pan)

      Assigns pitch and rhythmic values to the note object upon creation Other values (e.g. dynamic) and given reasonable defaults
      Parameters:
        `MIDI` - pitch range is 0-127 (middle c = 60): Constant values representing pitch values can be found in JMC
        `rhythmValue` - 0.5 = quaver: constant values representing most duration types can be found in JMC
        `dynamic` - range is 0-127 (0 = off; 127 = loud): Constant values representing some basic dynamic types can be found in JMC
        `pan` - Specifies the balance between output channels; usually between 0 - left, and 1 - right.

    - #### Note

          public Note(double frequency,
              double rhythmValue)

      Assigns frequency and rhythmic values to the note object upon creation
      Parameters:
        `frequency` - Pitch in hertz, any double value (A4 = 400)
        `rhythmValue` - 0.5 = quaver: constant values representing most duration types can be found in JMC

    - #### Note

          public Note(double frequency,
              double rhythmValue,
              int dynamic)

      Assigns frequency and rhythmic values to the note object upon creation
      Parameters:
        `frequency` - Pitch in hertz, any double value (e.g., A4 = 440.0)
        `rhythmValue` - 0.5 = quaver: constant values representing most duration types can be found in JMC
        `dynamic` - range is 0-127 (0 = off; 127 = loud): Constant values representing some basic dynamic types can be found in JMC

    - #### Note

          public Note(double frequency,
              double rhythmValue,
              int dynamic,
              double pan)

      Assigns frequency and rhythmic values to the note object upon creation
      Parameters:
        `frequency` - Pitch in hertz, any double value (e.g., A4 = 440.0)
        `rhythmValue` - 0.5 = quaver: constant values representing most duration types can be found in JMC
        `dynamic` - range is 0-127 (0 = off; 127 = loud): Constant values representing some basic dynamic types can be found in JMC
        `pan` - Specifies the balance between output channels; usually between 0 - left, and 1 - right.

    - #### Note

          public Note(java.lang.String note)

  - ### Method Detail

    - #### getPitchType

          public boolean getPitchType()

      Retrieve note's pitch type
      Returns:
        boolean notes pitch type

    - #### setPitchType

          public void setPitchType(boolean newType)

      Specifies the note's pitch type. There are constants for FREQUENCY and MIDI_PITCH
      Parameters:
        `boolean` - note's pitch type

    - #### getFrequency

          public double getFrequency()

      Retrieve the note's pitch as a frequency
      Returns:
        double note's pitch

    - #### setFrequency

          public void setFrequency(double freq)

      Assign notes pitch as a frequency. If the parameter `pitch` is less than `MIN_FREQUENCY` then the pitch of this note will be set to MIN_FREQUENCY.
      Parameters:
        `double` - note pitch as a frequency in hertz

    - #### getPitch

          public int getPitch()

      Retrieve the note's pitch as an integer. Useful for working with pitch as MIDI note numbers.
      Returns:
        int note's pitch

    - #### setPitch

          public void setPitch(int pitch)

      Assign notes pitch. If the parameter `pitch` is less than `MIN_PITCH` then the pitch of this note will be set to MIN_PITCH. Likewise, if `pitch` is greater than `MAX_MIDI_PITCH`, pitch will be set to MAX_MIDI_PITCH.
      Parameters:
        `int` - notes pitch

    - #### getRhythmValue

          public double getRhythmValue()

      Retrieve note's rhythmValue
      Returns:
        float notes rhythmValue

    - #### setRhythmValue

          public void setRhythmValue(double rhythmValue)

      Assign notes rhythmValue
      Parameters:
        `float` - notes rhythmValue

    - #### getDynamic

          public int getDynamic()

      Retrieve notes dynamic
      Returns:
        int notes dynamic

    - #### setDynamic

          public void setDynamic(int dynamic)

      Assign notes dynamic
      Parameters:
        `int` - notes dynamic

    - #### getPan

          public double getPan()

      Retrieves note's pan. 0.0 (full left) 0.5 (center) 1.0 (full right)
      Returns:
        notes pan

    - #### setPan

          public void setPan(double pan)

      Assign notes pan. 0.0 (full left) 0.5 (center) 1.0 (full right).
      Parameters:
        `double` - note's pan

    - #### getDuration

          public double getDuration()

      Return note duration. 1.0 = Crotchet (Quater Note), 0.5 = Quaver (Eighth Note), etc...
      Returns:
        double note's duration

    - #### setDuration

          public void setDuration(double duration)

      Set notes duration. 1.0 = Crotchet (Quater Note), 0.5 = Quaver (Eighth Note), etc...
      Parameters:
        `double` - note's duration

    - #### getOffset

          public double getOffset()

      Return note offset. The range is 0 = no change, positive number delay the note, negative values rush (advance) it
      Returns:
        double note's offset

    - #### setOffset

          public void setOffset(double offset)

      Set notes offset. The range is 0 = no change, positive number delay the note, negative values rush (advance) it
      Parameters:
        `double` - note's offset

    - #### getSampleStartTime

          public double getSampleStartTime()

      Return note sampleStartTime
      Returns:
        int note's sampleStartTime

    - #### setSampleStartTime

          public void setSampleStartTime(double sampleStartTime)

      Set notes sampleStartTime
      Parameters:
        `int` - note's sampleStartTime

    - #### setMyPhrase

          public void setMyPhrase(Phrase phr)

      Sets a reference to the phrase that contains this note

    - #### getMyPhrase

          public Phrase getMyPhrase()

      Return a reference to the phrase containing this note

    - #### copy

          public Note copy()

      Returns a copy of this note
      Returns:
        Note

    - #### setBreakPoints

          public void setBreakPoints(int index,
                            double[] points)

      Specify the values for a break point envelope. Some indexes of the breakPoints array are reserved for specific purposes. See the Note constants for a list of these.
      Parameters:
        `index` - The specific breakPoint number to set.
        `points` - The values for this break point array.

    - #### getBreakPoints

          public double[] getBreakPoints(int index)

      Retrieve the break point envelope values. Some indexes of the breakPoints array are reserved for specific purposes. See the Note constants for a list of these.
      Returns:
        double[] The break oint values for the specified index

    - #### toString

          public java.lang.String toString()

      Collects a string of the notes attributes
      Overrides:
        `toString` in class `java.lang.Object`

    - #### isScale

          public boolean isScale(int[] scale)

      Checks if the note is within a particular scale There are a number of scale constants specified in the JMC which can be used with this method, these include MAJOR_SCALE, MINOR_SCALE, and PENTATONIC_SCALE
      Parameters:
        `int[]` - - an array of scale degrees
      Returns:
        boolean - true means it is in the scale

    - #### setRhythmValue

          public void setRhythmValue(double rv,
                            boolean factorDuration)

      Sets the rhythmValue, and optionally change the duration at the same time.
      Parameters:
        `factorDuration` - wether or not to change the duration to be a multiple of the rhythm value as well

    - #### freqToMidiPitch

          public static int freqToMidiPitch(double freq)

      Convert a frequency into a MIDI note pitch. Assumes A440 and equal tempered intonation. Adapted from C code written by Andrew Botros.
      Parameters:
        `freq` - The frequency value to convert.
      Returns:
        int The MIDI pitch number closest to the input frequency.

    - #### midiPitchToFreq

          public static double midiPitchToFreq(int midiPitch)

      Calculate the frequency in hertz of a MIDI note pitch. Assumes an A440.0 reference and equal tempered intonation. Written by Andrew Brown based on C code by Andrew Botros.
      Parameters:
        `midiPitch` - The note pitch value to convert.
      Returns:
        double The frequency equivalent in cycles per second.

    - #### isRest

          public boolean isRest()

      Check if the note is a rest or a pitched note.
      Returns:
        boolean True if the note is a rest otherwise false.

    - #### setLength

          public void setLength(double newLength)

      Change both the rhythmValue and duration of a note in the one step.
      Parameters:
        `newLength` - The new rhythmValue for the note (Duration is a proportion of this value)

    - #### isSharp

          public boolean isSharp()

      tells whether the note is a sharp or not
      Returns:

    - #### isFlat

          public boolean isFlat()

      tells whether the note is a sharp or not by using its string value
      Returns:

    - #### isNatural

          public boolean isNatural()

      tells whether the note is natural or not
      Returns:

    - #### samePitch

          public boolean samePitch(Note note)

    - #### sameDuration

          public boolean sameDuration(Note note)

    - #### equals

          public boolean equals(Note note)

    - #### nextNote

          public Note nextNote(int[] scale)

      gives the next note in the scale For example, if inputting a D note for a DMinor scale, the next note returned is an E if inputing a Bb for a C
      Parameters:
        `scale` - a constant from Scales.java goes here
      Returns:

    - #### getPitchValue

          public int getPitchValue()

      returns the pitches for the middle scale(default) on a keyboard

    - #### getNote

          public java.lang.String getNote()

      gets the string representation for a note for a given MIDI pitch (0-127)
      Returns:

    - #### getNote

          public static java.lang.String getNote(int pitch)

      gets the string representation for a note for a given MIDI pitch (0-127)
      Returns: