コード例 #1
0
        public PairList GetChords()
        {
            Dict chord = new Dict();

            //string[] NoteName = NoteNameSharp;

            for (int i = 0; i < notes.Count; i++)
            {
                int    note  = notes[i];
                double decay = hold[i] ? 0.5 : 1;
                int    scale;
                // Major
                scale = NoteScale.FromNumber(note);     // as 1th
                Acc(chord, NoteName[scale], decay / 3);
                scale = NoteScale.FromNumber(note - 4); // as 3th
                Acc(chord, NoteName[scale], decay / 3);
                scale = NoteScale.FromNumber(note - 7); // as 5th
                Acc(chord, NoteName[scale], decay / 3);
                // Minor
                scale = NoteScale.FromNumber(note);     // as 1th
                Acc(chord, NoteName[scale] + "m", decay / 3);
                scale = NoteScale.FromNumber(note - 3); // as 3th
                Acc(chord, NoteName[scale] + "m", decay / 3);
                scale = NoteScale.FromNumber(note - 7); // as 5th
                Acc(chord, NoteName[scale] + "m", decay / 3);
                // 7th
                scale = NoteScale.FromNumber(note);      // as 1th
                Acc(chord, NoteName[scale] + "7", decay / 4);
                scale = NoteScale.FromNumber(note - 4);  // as 3th
                Acc(chord, NoteName[scale] + "7", decay / 4);
                scale = NoteScale.FromNumber(note - 7);  // as 5th
                Acc(chord, NoteName[scale] + "7", decay / 4);
                scale = NoteScale.FromNumber(note - 10); // as 7th
                Acc(chord, NoteName[scale] + "7", decay / 4);
            }
            if (l != null)
            {
                PairList chord_l = l.GetChords();
                foreach (var pair in chord_l)
                {
                    Acc(chord, pair.Key, pair.Value);
                }
            }
            if (r != null)
            {
                PairList chord_r = r.GetChords();
                foreach (var pair in chord_r)
                {
                    Acc(chord, pair.Key, pair.Value / 2);
                }
            }
            List <KeyValuePair <string, double> > ret = new List <KeyValuePair <string, double> >();

            foreach (var c in chord)
            {
                ret.Add(c);
            }
            ret.Sort((a, b) => (b.Value.CompareTo(a.Value)));
            return(ret);
        }
コード例 #2
0
        /** Given a midi note number, return the accidental (if any)
         * that should be used when displaying the note in this key signature.
         *
         * The current measure is also required.  Once we return an
         * accidental for a measure, the accidental remains for the
         * rest of the measure. So we must update the current keymap
         * with any new accidentals that we return.  When we move to another
         * measure, we reset the keymap back to the key signature.
         */
        public Accid GetAccidental(int notenumber, int measure)
        {
            if (measure != prevmeasure)
            {
                ResetKeyMap();
                prevmeasure = measure;
            }

            Accid result = keymap[notenumber];

            if (result == Accid.Sharp)
            {
                keymap[notenumber]     = Accid.None;
                keymap[notenumber - 1] = Accid.Natural;
            }
            else if (result == Accid.Flat)
            {
                keymap[notenumber]     = Accid.None;
                keymap[notenumber + 1] = Accid.Natural;
            }
            else if (result == Accid.Natural)
            {
                keymap[notenumber] = Accid.None;
                int nextkey = NoteScale.FromNumber(notenumber + 1);
                int prevkey = NoteScale.FromNumber(notenumber - 1);

                /* If we insert a natural, then either:
                 * - the next key must go back to sharp,
                 * - the previous key must go back to flat.
                 */
                if (keymap[notenumber - 1] == Accid.None && keymap[notenumber + 1] == Accid.None &&
                    NoteScale.IsBlackKey(nextkey) && NoteScale.IsBlackKey(prevkey))
                {
                    if (num_flats == 0)
                    {
                        keymap[notenumber + 1] = Accid.Sharp;
                    }
                    else
                    {
                        keymap[notenumber - 1] = Accid.Flat;
                    }
                }
                else if (keymap[notenumber - 1] == Accid.None && NoteScale.IsBlackKey(prevkey))
                {
                    keymap[notenumber - 1] = Accid.Flat;
                }
                else if (keymap[notenumber + 1] == Accid.None && NoteScale.IsBlackKey(nextkey))
                {
                    keymap[notenumber + 1] = Accid.Sharp;
                }
                else
                {
                    /* Shouldn't get here */
                }
            }
            return(result);
        }
コード例 #3
0
        /** The keymap tells what accidental symbol is needed for each
         *  note in the scale.  Reset the keymap to the values of the
         *  key signature.
         */
        private void ResetKeyMap()
        {
            Accid[] key;
            if (num_flats > 0)
            {
                key = flatkeys[num_flats];
            }
            else
            {
                key = sharpkeys[num_sharps];
            }

            for (int notenumber = 0; notenumber < 128; notenumber++)
            {
                keymap[notenumber] = key[NoteScale.FromNumber(notenumber)];
            }
        }
コード例 #4
0
        /** Return the midi note number corresponding to this white note.
         * The midi note numbers cover all keys, including sharps/flats,
         * so each octave is 12 notes.  Middle C (C4) is 60.  Some example
         * numbers for various notes:
         *
         *  A 2 = 33
         *  A#2 = 34
         *  G 2 = 43
         *  G#2 = 44
         *  A 3 = 45
         *  A 4 = 57
         *  A#4 = 58
         *  B 4 = 59
         *  C 4 = 60
         */

        public int Number()
        {
            int offset = 0;

            switch (letter)
            {
            case A: offset = NoteScale.A; break;

            case B: offset = NoteScale.B; break;

            case C: offset = NoteScale.C; break;

            case D: offset = NoteScale.D; break;

            case E: offset = NoteScale.E; break;

            case F: offset = NoteScale.F; break;

            case G: offset = NoteScale.G; break;

            default: offset = 0; break;
            }
            return(NoteScale.ToNumber(offset, octave));
        }
コード例 #5
0
        /** Get the letter (A, A#, Bb) representing this note */
        private string Letter(int notenumber, WhiteNote whitenote)
        {
            int notescale = NoteScale.FromNumber(notenumber);

            switch (notescale)
            {
            case NoteScale.A: return("A");

            case NoteScale.B: return("B");

            case NoteScale.C: return("C");

            case NoteScale.D: return("D");

            case NoteScale.E: return("E");

            case NoteScale.F: return("F");

            case NoteScale.G: return("G");

            case NoteScale.Asharp:
                if (whitenote.Letter == WhiteNote.A)
                {
                    return("A#");
                }
                else
                {
                    return("Bb");
                }

            case NoteScale.Csharp:
                if (whitenote.Letter == WhiteNote.C)
                {
                    return("C#");
                }
                else
                {
                    return("Db");
                }

            case NoteScale.Dsharp:
                if (whitenote.Letter == WhiteNote.D)
                {
                    return("D#");
                }
                else
                {
                    return("Eb");
                }

            case NoteScale.Fsharp:
                if (whitenote.Letter == WhiteNote.F)
                {
                    return("F#");
                }
                else
                {
                    return("Gb");
                }

            case NoteScale.Gsharp:
                if (whitenote.Letter == WhiteNote.G)
                {
                    return("G#");
                }
                else
                {
                    return("Ab");
                }

            default:
                return("");
            }
        }
コード例 #6
0
 /** Get the name for this note */
 private string NoteName(int notenumber, WhiteNote whitenote)
 {
     if (sheetmusic.ShowNoteLetters == MidiOptions.NoteNameLetter)
     {
         return(Letter(notenumber, whitenote));
     }
     else if (sheetmusic.ShowNoteLetters == MidiOptions.NoteNameFixedDoReMi)
     {
         string[] fixedDoReMi =
         {
             "La", "Li", "Ti", "Do", "Di", "Re", "Ri", "Mi", "Fa", "Fi", "So", "Si"
         };
         int notescale = NoteScale.FromNumber(notenumber);
         return(fixedDoReMi[notescale]);
     }
     else if (sheetmusic.ShowNoteLetters == MidiOptions.NoteNameMovableDoReMi)
     {
         string[] fixedDoReMi =
         {
             "La", "Li", "Ti", "Do", "Di", "Re", "Ri", "Mi", "Fa", "Fi", "So", "Si"
         };
         int mainscale = sheetmusic.MainKey.Notescale();
         int diff      = NoteScale.C - mainscale;
         notenumber += diff;
         if (notenumber < 0)
         {
             notenumber += 12;
         }
         int notescale = NoteScale.FromNumber(notenumber);
         return(fixedDoReMi[notescale]);
     }
     else if (sheetmusic.ShowNoteLetters == MidiOptions.NoteNameFixedNumber)
     {
         string[] num =
         {
             "10", "11", "12", "1", "2", "3", "4", "5", "6", "7", "8", "9"
         };
         int notescale = NoteScale.FromNumber(notenumber);
         return(num[notescale]);
     }
     else if (sheetmusic.ShowNoteLetters == MidiOptions.NoteNameMovableNumber)
     {
         string[] num =
         {
             "10", "11", "12", "1", "2", "3", "4", "5", "6", "7", "8", "9"
         };
         int mainscale = sheetmusic.MainKey.Notescale();
         int diff      = NoteScale.C - mainscale;
         notenumber += diff;
         if (notenumber < 0)
         {
             notenumber += 12;
         }
         int notescale = NoteScale.FromNumber(notenumber);
         return(num[notescale]);
     }
     else
     {
         return("");
     }
 }
コード例 #7
0
        /** Given a midi note number, return the white note (the
         * non-sharp/non-flat note) that should be used when displaying
         * this note in this key signature.  This should be called
         * before calling GetAccidental().
         */
        public WhiteNote GetWhiteNote(int notenumber)
        {
            int notescale = NoteScale.FromNumber(notenumber);
            int octave    = (notenumber + 3) / 12 - 1;
            int letter    = 0;

            int[] whole_sharps =
            {
                WhiteNote.A, WhiteNote.A,
                WhiteNote.B,
                WhiteNote.C, WhiteNote.C,
                WhiteNote.D, WhiteNote.D,
                WhiteNote.E,
                WhiteNote.F, WhiteNote.F,
                WhiteNote.G, WhiteNote.G
            };

            int[] whole_flats =
            {
                WhiteNote.A,
                WhiteNote.B,WhiteNote.B,
                WhiteNote.C,
                WhiteNote.D,WhiteNote.D,
                WhiteNote.E,WhiteNote.E,
                WhiteNote.F,
                WhiteNote.G,WhiteNote.G,
                WhiteNote.A
            };

            Accid accid = keymap[notenumber];

            if (accid == Accid.Flat)
            {
                letter = whole_flats[notescale];
            }
            else if (accid == Accid.Sharp)
            {
                letter = whole_sharps[notescale];
            }
            else if (accid == Accid.Natural)
            {
                letter = whole_sharps[notescale];
            }
            else if (accid == Accid.None)
            {
                letter = whole_sharps[notescale];

                /* If the note number is a sharp/flat, and there's no accidental,
                 * determine the white note by seeing whether the previous or next note
                 * is a natural.
                 */
                if (NoteScale.IsBlackKey(notescale))
                {
                    if (keymap[notenumber - 1] == Accid.Natural &&
                        keymap[notenumber + 1] == Accid.Natural)
                    {
                        if (num_flats > 0)
                        {
                            letter = whole_flats[notescale];
                        }
                        else
                        {
                            letter = whole_sharps[notescale];
                        }
                    }
                    else if (keymap[notenumber - 1] == Accid.Natural)
                    {
                        letter = whole_sharps[notescale];
                    }
                    else if (keymap[notenumber + 1] == Accid.Natural)
                    {
                        letter = whole_flats[notescale];
                    }
                }
            }

            /* The above algorithm doesn't quite work for G-flat major.
             * Handle it here.
             */
            if (num_flats == Gflat && notescale == NoteScale.B)
            {
                letter = WhiteNote.C;
            }
            if (num_flats == Gflat && notescale == NoteScale.Bflat)
            {
                letter = WhiteNote.B;
            }

            if (num_flats > 0 && notescale == NoteScale.Aflat)
            {
                octave++;
            }

            return(new WhiteNote(letter, octave));
        }
コード例 #8
0
 /** Get the color for a given note number */
 public Color NoteColor(int number)
 {
     return(NoteColors[NoteScale.FromNumber(number)]);
 }