I need a Python programmer and musician to generate chord voicings for any stringed instrument with a default setting for 6-string guitar in standard tuning.
Your inputs will be:
1) The open string tuning for an instrument for each string eg [E,A,D,G,B,E] for 6-string guitar.
2) The key or root note for the chord eg "A"
3) The Chord Type eg "m7b5"
I will provide is a list of 130 or so chord names and their intervals in Chords3.csv file.
Your task is to generate as many different combinations of positions as you can for every chord, between a given set of frets. The space in which you should generate these chords should be from fret 0 - 17.
There are however some limits to the number of frets a human can stretch to hold a chord, which is 5-7 frets, with it being more difficult to stretch far near the neck (low fret numbers) and easier to stretch further, closer to the body of the guitar (high fret numbers).
The amount of voicings per chord could be anywhere between 20-60 or more. You should set a trigger to stop searching after x-amounts of voicings have been generated for each chord to reduce run-time of the program.
To see how various voicings might look for an E major and E7 chord turn to pages 2-5 of the pdf below.
You may use various tricks or methods to achieve all the voicings, and you may want to limit yourself to chords without note doubling. You may even want to limit yourself to picking 4 of the most important intervals in larger chords by dropping the 5th, the 3rd or in some cases even the root.
You could experiment with an unstructured approach by generating random shapes within a range of 5-7 frets which fall on the intervals of the chord and checking if you have already saved it, however you may save computing time with a more structured approach for certain kinds of chords.
For example you might decide to write separate algorithms for 3-note chords and 4-note chords without note doubling. One helpful approach might be to systematically generate certain kinds of voicings such as drop 2 chords, drop 3, drop 2 3, drop 2 4, drop 3 4, drop 2 3 4, drop 2 2, drop 2 2 3, drop 2 2 4, drop 2 2 3 4, drop 2 3 3, drop 2 3 3 4 etc. See the link below.
I highly suggest learning how guitar voicing innovator Ted Greene is able to generate systematic inversions for 4-note chords in his V-System.
The output of your voicings eg for 6-string guitar in standard tuning should be a csv file with at minimum a format similar to
Chord Name, Chord Type,Ft-E,Ft-A,Ft-D,Ft-G,Ft-B,Ft-e,Lowest Note
"Lowest Note" will contain the lowest sounding note of the chord. For example, with A major chord on frets [x,x,2,2,2,x] should have "E" as the lowest sounding note in the chord.
I will also have a sample database as a csv file which I can provide to you as a way to test your program. If you combine your output, and the sample database, duplicates will mean you've done something right. I may also be able to test the quality of your data with another algorithm that can rate how difficult a chord is to play so that unusable chords are discarded.
To get started on the project I have some files to help you:
If you require some note names and interval names you may find some here:
Please reuse any code you need from the main file
return_semitone_distance(root_note, note): to return the semitones between to notes
return_interval(root_note, note): to return the interval between two notes
chord_chart(tonic, chord_type, fret_position): to draw a fretboard
return_note_names(fret_position): returns the note names for the strings from left to right eg ['F','A','C','E']
Tunings for various instruments may be found here:
You might find these functions "joni_mitchell_tuning(tuning)" and "show_mitchell_tunings()" useful