Chord Identification using DryWetMIDI

[Jenix-Park]

Hello,

I am planning to incorporate a functionality that allows users to identify a chord name with two or more given notes.
To test this feature, I ran the following code:

var chord1 = new Melanchall.DryWetMidi.MusicTheory.Chord(NoteName.C, NoteName.E, NoteName.G);
var chord2 = new Melanchall.DryWetMidi.MusicTheory.Chord(NoteName.E, NoteName.C, NoteName.G);

foreach (var chordName in chord1.GetNames())
    Console.WriteLine(chordName);

Console.WriteLine();

foreach (var chordName in chord2.GetNames())
    Console.WriteLine(chordName);

The outputs I received were as follows:

C
CM
Cmaj
C5/E

C
CM
C5/E
Cmaj

However, I would prefer the following:

1. Instead of suggesting multiple possible chords, I would like to print the most suitable chord name.
   In the mentioned case, the desired results would be "C/E" and "Cmaj" respectively.
   (At least, I can live with the "C5/E" output in the first case, though)

2. It would be convenient if I could directly pass note numbers rather than note names.
   My application utilizes note numbers for various tasks, and converting or creating new Note objects could result in unnecessary garbage collection and overhead.
   Performance is a primary concern for me, so I would like to avoid any additional layers if possible.

Is it possible to achieve these with the library?
If not, do you know any other library for this specific case?
ChatGPT recommended NAudio, but it doesn't seem to be a proper one.

I greatly appreciate your plugin, which has been of tremendous help to me.

Thank you for your ongoing support.

[melanchall]

Hello,

1. First of all, it's required to return multiple names due to the simple thing: different people name the same chord differently :-) As for most suitable names I suppose you mean C/E for second chord (E C G) and Cmaj (C E G) for the first one. Even here we can see that you prefer to name the first chord Cmaj but there are many people who will name it just C.

   But your idea is interesting. Hmm... Placing a name where root note matches a chord's root note to the first place in a result. I should think but now that's not possible. Names are sorted by their lengths.

2. A music theory chord is a set of notes without octaves so I think the current way is a proper one. But you can easily get names from numbers:

   var noteNames = noteNumbers
       .Select(n => NoteUtilities.GetNoteName((SevenBitNumber)n))
       .ToArray();

If not, do you know any other library for this specific case?
ChatGPT recommended NAudio, but it doesn't seem to be a proper one.

I don't know such libraries for .NET. You can try to search for libraries for other languages. NAudio is a great library, but it's not for MIDI, it's for audio. Yes, it has MIDI API, but it's super low level and exists only to exist (the author of the library said that directly in one of the issues).

[Jenix-Park]

DryWetMIDI is hands down the absolute best when it comes to MIDI features!
I can't imagine my music journey without it, and I have no desire to switch to any other plugins.

By the way, I was actually excited about the chord identification feature in DryWetMIDI since I thought it was already available.
I totally get what you said, but I was just hoping there was a way to provide users with a friendly guidance, just like those Casio keyboards and Logic Pro do, by showing a single chord.

But hey, no worries!
I understand that the final decision is up to me, and I'll take the time to consider my options and pick the one that suits me best.

Oh, and about NAudio?
Honestly, I don't know much about it.
I was just curious to see if it had any chord identification capabilities.

I want to sincerely thank you for your super quick and kind response.
Your help has been beyond amazing and incredibly appreciated! You rock!

[Jenix-Park]

@melanchall Oh, by the way, what will happen if all twelve or random notes are passed to the Chord class and the GetNames() method is called?
My main concern here is whether it is acceptable to directly pass all the notes inputted by a user to the Chord class, without requiring my app to specifically identify and ignore those cases.

[melanchall]

Thank you for such kind words!

I totally get what you said, but I was just hoping there was a way to provide users with a friendly guidance, just like those Casio keyboards and Logic Pro do, by showing a single chord.

I'll think about adding some parameter to the GetNames method to specify sorting algorithm, but unfortunately that won't be in an upcoming release. Anyway thank you for your suggestion.

Oh, by the way, what will happen if all twelve or random notes are passed to the Chord class and the GetNames() method is called?

GetNames will return an empty collection because DryWetMIDI doesn't know such a chord. The library uses Chords names table (CNT) to identify a chord's name so you can follow the link and see what chords are currently can be recognized. DryWetMIDI uses CNT instead of some algorithmic solution to provide best performance of the operation.

[Jenix-Park]

Then, I guess I can simply throw all the notes into the Chord class and see if it returns an empty collection, haha. I'm not sure about the performance efficiency, but at least the code will be much simpler.

Thanks a lot!

[Jenix-Park]

@melanchall Sorry, I have one final question.
This time, I have decided to consistently exclude slash chords.
In the previous example, I will choose between C, CM, and Cmaj, but not C5/E.

Is there a possibility that only one slash chord will be returned?
I ask this because I plan to disregard any chords that include the '/' character. This could be problematic if there is a scenario where only one slash chord is returned.

[melanchall]

@Jenix-Park I've built the Melanchall.DryWetMidi-7.0.2-prerelease7 version. Can you please try it and let me know how fast it is? My benchmarks show significant speed up.

Also the algorithm will exit immediately now if notes count is greater than supported by the algorithm (in this case we know for sure that we won't find any name so there is no need to run detection routine at all). More than that, implementation is now simpler and doesn't use permutations.

Also I found a bug in 9sus2 chords detection :-)

[Jenix-Park]

@melanchall
WOW!

I’m absolutely thrilled with your new code version—it’s like lightning in a bottle! It’s so quick that I can barely believe it doesn’t add even a smidge of latency, no matter how many notes I throw at it. 😄
(Just a quick heads up, I whipped up my test code pretty quickly, so there might be a few hiccups there. Plus, I ran it on my PC, so things might be a tad different on less powerful devices.)

I’ve got a couple of questions on my mind:

1. Does this awesome update mean I can send all the user input straight through without having to filter it first?
2. Can it handle heaps of notes, like 9 or 10?
3. I’m curious if there’s any way to tweak my GetChordNames() method below to make it even more efficient—any thoughts on minimizing overhead from things like garbage collection, memory allocation, or method calls?

Thanks a million for your amazing work and your time!

class TestProgram
{
    const int TEST_COUNT = 500000;

    const int MIN_USERINPUT = 3;    // 0 ~ 88 (Minimum count of piano keys pressed by the user)
    const int MAX_USERINPUT = 12;


    static List<NoteName> noteNameListToCheck = new List<NoteName>(88);

    static IReadOnlyCollection<string> GetChordNames(List<int> noteNumbers)
    {
        // This removes duplicates of note names across different octaves, treating them as a single note.
        var uniqueNoteNumbers = noteNumbers
            .Select(n => n % 12)
            .Distinct();

        if (uniqueNoteNumbers.Count() < 2)
        {
            noteNameListToCheck.Clear();

            return Array.Empty<string>();
        }

        foreach (var noteNumber in uniqueNoteNumbers)
            noteNameListToCheck.Add(NoteUtilities.GetNoteName((SevenBitNumber)noteNumber));

        var chordNames = new Chord(noteNameListToCheck).GetNames();

        noteNameListToCheck.Clear();

        return chordNames;
    }


    static Random randomObj = new Random();
    static HashSet<int> uniqueNumbers = new HashSet<int>();

    static void SimulateUserInput(List<int> list)
    {
        var elementCount = randomObj.Next(MIN_USERINPUT, MAX_USERINPUT + 1);

        while (uniqueNumbers.Count < elementCount)
        {
            var number = randomObj.Next(1, 89);
            uniqueNumbers.Add(number);
        }

        list.AddRange(uniqueNumbers);

        uniqueNumbers.Clear();
    }


    static void Main(string[] args)
    {
        List<int> userInput = new List<int>(88);

        Stopwatch sw = new Stopwatch();

        for (int i = 0; i < TEST_COUNT; ++i)
        {
            userInput.Clear();

            SimulateUserInput(userInput);

            // Temporarily disabling this to test with simulated user input.
            //if (userInput.Count < 2)
            //    continue;

            sw.Start();

            var chordNames = GetChordNames(userInput);

            sw.Stop();

            if (chordNames.Count > 0)
            {
                foreach (var chordName in chordNames)
                    Console.Write(chordName + ", ");

                Console.WriteLine();
            }
        }

        Console.WriteLine("----------------------------------------------------------");
        Console.WriteLine("Total : " + sw.Elapsed.TotalMilliseconds);
        Console.WriteLine("Average : " + sw.Elapsed.TotalMilliseconds / TEST_COUNT);
    }
}

[melanchall]

@Jenix-Park Great news!

Does this awesome update mean I can send all the user input straight through without having to filter it first?

Yes. All required filtering will be applied within the GetNames method.

Can it handle heaps of notes, like 9 or 10?

Yes. With a lot of notes the method will just exit immediately because there is no rules (in the library) for such chords how to name them.

I’m curious if there’s any way to tweak my GetChordNames() method below to make it even more efficient—any thoughts on minimizing overhead from things like garbage collection, memory allocation, or method calls?

Hmm, your method is already simple, so I don't see obvious ways to improve the code.

Thank you for your questions and issues!

[Jenix-Park]

@melanchall I just gave the old version a spin with my test code from above, and wow, what a difference!
It was pretty much a no-go.
The new version, on the other hand, is like night and day—it's amazing!
Can't wait for the official release to drop.

Thanks a million for all your hard work and for getting back to me. You rock! :)

[melanchall]

@Jenix-Park Thank you! Unfortunately I can't provide you any date when the release will happen :-(

[Tony-Pappas]

Hey guys, you may want to look at Adrian Akison's 2008 article (and the demo code) for permutations. The performance is ripping fast. https://www.codeproject.com/Articles/26050/Permutations-Combinations-and-Variations-using-C-G

[melanchall]

In fact, there is no need in permutations in the chord name detection algorithm. But thank you anyway :-)

[valimaties]

I love to see this feature.
I don't know if any of you play arrangers (Yamaha, Korg, etc). However, I have a Yamaha Genos and also a Korg PA5X. These ones have some "advanced" modes for detecting chords based on note you played in the arrangement section. The best one from these two ones is Genos, which AI mode detection is very very well done.
For example, when you play only G-E this will be translated into a Em/G chord, so a Emin with a G in bass (last picture).
I will attach some pictures to see how the keyboard recognized those "2-keys" chords:

C/E

C/G

Em/G

[melanchall]

Hi,

Interesting feature to guess a chord by two notes. But I have questions. Let's see at G E. Your device recognized this sequence as Em/G. But why not C, for example? Both Em and C chords have G and E notes, so if we are agreed to ignore a third note, we have in fact several variants, havent't we?

[valimaties]

Em is composed of E-G-B notes. When I have only two notes involved, like E and G , the heigher note gives me the chord (E) and the second note gives me the bass note and in the same time tells keyboard what type of chord is, minor or major. Because G is the minor 3rd of the E chord then the result is a Em/G . If the E had been in the same octave (the heigher key had been G) the keyboard had been translate it as a Em chord, simple.
For the case of GC, the higher note is C, which compose the C chord. The G is lower note, so tells keyboard that it must be the bass note as well, and in the same time is the fifth note in the chord, no minor 3rd or major 3rd involved, so the keyboard decide that is a major chord.

For the Em/G case, if instead of G I take G# it will be a E/G# :) Nice, isn't it?

PS: Chords like X/Y will be composed like this only if X key is in the next octave!

[melanchall]

@valimaties Thanks for the explanation! I'll think about how to integrate similar logic into the library.

[valimaties]

Be aware of those chords created with two notes, when notes belong to the same octave. These are in strong bound with the Chord Fingering type in the arranger. The above chord recognition is available only in AI fingered mode on Yamaha and Expert(Advanced) mode on Korg. If the Chord Fingering is other than those two, the recognition will be changed accordingly.
If for example Chord Fingering is Single finger - A#(2) C3 (2 and 3 are octave no) is not recognized as a chord with specific bass note, but is recognized as Cm, B C is recognized as C7, as well as the three notes like A# B C (in this order) is recognized as a Cm7.

Now, if in Single finger the Cm chord is recognized using A# C notes in this order, in AI mode the Cm chord is the C D# notes, in the same octave.

So, in arrangers world those two-notes chords having different bass note are recognized only in those Chord Fingering "special (advanced)" modes.

Regards,
Vali