kjossul/licksterr

A platform that matches songs with scales, chords and other musical concepts.

licksterr's Issues

Simplify forms

At the moment, each form includes notes up to two frets below the leftmost root (to solve the 'Gb` issue where open strings would not be counted) and one fret above the rightmost root.
Instead, each box should include notes in scale order, preferring notes that are inside the root shape. This can be easily fixed by introducing a "simplify" function that removes redundant notes from the shape (e.g. by giving a score to each note, the farther from a root fret-wise the worst). Comparison should be done considering two strings at a time.

Provide option to change key of track

The key finder is not perfect, users should be able to change wrongly identified keys

Create intelligent endpoint for form matching

Currently, two endpoints are up for getting tracks and single measures info. This works fine, but the list of matching form for each measure is huge.
Here is an idea: create an endpoint for track analysis that instead of returning single ids in the measure field, it returns measure matches giving a greater score to the forms that appear across multiple measures (a simple average and a threshold should work, the value probably needs some tuning but 20% should be a good start)

Add favicon and logo

Use different key-profiles for key analysis

A list of other key profiles is described here.
Maybe combining all of them will yield better results.

Parse melody tracks only

A lot of guitarpro tabs have side tracks that are not really interesting. An option should be present in the endpoint to allow parsing only for the given indexes.

Create a better fretboard to use to plot the info

Use heatmap values with HSL to display analysis output

In this way color transitions will be seamless, instead of having 5 fixed values.

Analyze chord changes in a song

This should be done by considering chord progressions

Scale fingerings

This is an interesting research paper over optimal guitar fingering.

Yield a pause after no note is played for some time

The amount of time has yet to be defined, but a full measure should be sufficient.

Store form shapes on file

It's useless to build them every time. Even a json file to store the shapes should be sufficient.
Also, refactor the form construction into analyzer.py for the same reason.

Consider intervals with multiple notes as well

E - 0 -- 2
B - 0 -- 2

Should be considered a single M2 interval, even though it's played on multiple strings.
Rules:

1. The number of strings played in the first and second beat should be the same
2. Comparing strings in ascending pitch, all intervals should be the same
3. The same rules for belonging in a form applies here (all notes should be included)

Save measures instead of licks

Licks at the moment are just stored as a bunch of notes. This is wrong, though, since a lick is also related to note duration. For this reason, it is more convenient to use a measure as the "atomic element" to compare against forms. Considering full measures is also easier to practice and combine licks.

Move form analysis into DBMS

Currently all the forms are stored inside a json file, while these should be moved into the DB now that models are up.
Consider refactoring of guitar.py to directly interface with db.Model classes.

Find key of the song

Currently, the parser simply stores for each note the amount of time that it was played. While this should be enough to determine the key at the end (the note played the most is likely the key), a more advanced analysis can be done, considering that usually licks start/end on roots, thirds and fifths. This kind of manual feature extraction could waste a lot of time though, so better considering it in the future only if the first methods fail consistently.

Make forms calculation tuning-dependent instead of hardcoded

This would be a nice addition but probably useless at the moment. Needs research from experts to see if it could be useful.

Improve colors in the image module

Drop interval matching and match forms instead

Intervals will be done in the future (and maybe not even that useful for the purpose of this project)

Identify (partial) shapes on different octaves

The analyzer should be able to identify forms even on partial shapes and on different octave.
For example, in the G Ionian the first 4 frets [0-3] are part of the G form transposed one octave below, even though the form is not in its full shape (the M7 on the G string is missing).

Rhythm analysis

• Some rhythms examples
• Paper about querying by rhythm in databases

Handle repeated measures

Change yield sounds logic to yield a group of notes instead one by one

Currently, each note is yield individually and this could result in multiple notes recognized in different scale. I think the solution is to yield notes in group, in such a way that the whole lick is returned.
The analysis on the forms should be done in a different function: first I should match a whole scale, and then look at what forms inside that scale are played more.

Songs with modulations (changing keys)

How should modulations be handled efficiently? Currently, the song updates the possible keys while it parses the song, so a modulation would not be detected.

Include open strings in the image module

Compare lick against forms efficiently

Currently there are 11 supported scales, with 12 keys each and 31 forms (combinations of different sizes of CAGED), for a total of roughly 4k forms to compare every time we find a lick.
Since we want to narrow down this number, I think the best way is to keep a dictionary similar to
d[note] = {set of forms that contain this note}
And update the possible scales by intersecting sets at each note. This should work as a first implementation, further ideas will be collected instead better performance is needed.

Determine intervals between adjacent notes in a song

Chords should be used as separators (i.e. if we have note - chord - note no interval should be computed).
"Long pauses" should be used as separators as well, but this might be hard to determine so it will be done in the future.

Find a way to highlight used notes of a form in a specific measure

Creating new images for each FormMeasure might not be feasible, so I have to find a way to directly change the svg.
EDIT: actually, there is no need to store svgs at all. We can fix a small size for PNGs and compress that way, easily staying in the MB range for the space needed.

Subclass FormImage

Move all drawing methods for a single form on this class.

Add Chords formulas

Complete list here

Minify vendor javascripts

Set up Flask endpoint to handle analysis

Since parser set up takes some time, it's moment to set up an endpoint to handle song parsing. This will be a feature of the application in the future anyways.

Give the otpion to recognize intervals present only for a single scale box

A possible use case can be to recognize intervals only inside a single box (i.e. setting prev = None when a note out of the box is played).
Note that with boxes I am referring to patterns (shapes) not positions. Explaining video

Incorporate other scale pattern techniques

There is other stuff aside from CAGED, such as 3 notes per string, Segovia and so on.

Move project files folder under /srv/www/licksterr