Merge pull request prathimacode-hub#1008 from theshredbox/main

Scale Chart for Musical Composition

Author: prathimacode-hub

GUIScripts/Scale Chart For Musical Composition/Images/Screenshot (504).png

@@ -0,0 +1,78 @@
+# 🎼 **SCALE CHART FOR MUSICAL COMPOSITION**
+<p align="center">
+  <img width="500" height="300" src="https://media.giphy.com/media/EA4ZexjGOnfP2/giphy.gif">
+</p>
+
+## :ideograph_advantage: **INTRODUCTION**
+* Beginners in the field of music learning, especially guitar learners face a lot of dilemma on where to begin with and many at times they lose a track of their learning which makes learning a complicated task. So to cut this slack off, we come with an easy, yet an efficient interface that would facilitate better learning.
+* Python 3 and Tk can be used for building a creative application that visually represents different scales, notes, modes, and keys. Such tools are particularly common for string instruments like the guitar. Here, the users can navigate different scales (major, natural minor, harmonic minor, pentatonic, blues, etc.) and chords (5 chords, major, minor, diminished, augmented, and so on) on a 24- fret chart. The purpose of this project is to create a program with which you can find the position of the notes of a given scale in the guitar. 
+
+## :question: **WHAT IS TKINTER ?**
+Python offers multiple options for developing GUI (Graphical User Interface). Out of all the GUI methods, tkinter is the most commonly used method. It is a standard Python interface to the Tk GUI toolkit shipped with Python. Python with tkinter is the fastest and easiest way to create the GUI applications. Creating a GUI using tkinter is an easy task.
+
+## ❓ **WHY EXACTLY DO WE NEED A SCALE CHART ?**
+Pretend that you can imagine the spectrum of audible sound, and try to divide it into a musical system that makes sense for you and everyone around you. This is not easy! After centuries of struggle, humans have come up with a system but there are still disputes going on. Using the intervals of a given scale as index, we can retrieve the notes that make up the scale. This is all you need to understand. We will be applying this principle over and over again to extract the notes that compose a given scale. Using this information, we will then plot where these notes are located in the guitar. These plots all together make a SCALE CHART.
+<p align="center">
+ <img width="500" height="300" src="https://user-images.githubusercontent.com/36481036/135743837-ef05b516-cb7b-409b-adec-6ab39fa94a8e.png">
+</p>
+
+
+## :bookmark: **MODULE DESCRIPTION**
+* The project being a GUI based application is made using Tkinter, a Python binding to the GUI toolkit. We started off from scratch and saw how we can use lists, dictionaries to build a tool that can help us play the guitar. We all know Music theory is a complex subject made up of a lot of components. For the purposes of this post, we will be simplifying things here quite a bit.
+* Here we will treat the fretboard as a UX Component and treat it as an image.  Based on the design guidelines and the test variations, we introduce potential flaws in direct correlation to the design input. These flawed design mockups are manifested as images. Proper labeling of these images ensure proper organization of test data. Once we have a minimal set of images in our arsenal, we are ready to train our model.
+
+![workflow](https://user-images.githubusercontent.com/36481036/135594695-dcba5d00-fc95-4ae8-abec-7d8d28ed54d5.png)
+
+## :bulb: **STEPS FOLLOWED**
+1. The first and the most important step was to import the tkinter package and the OrderedDict package.
+2. Then we needed to define the notes that would help us to get a Note name from 0-11 INT.
+3. After entering the name of the scales in a rotated sorted array, we return a scale of 16 notes.
+4. Then we set the default scale and the offnote.
+5. When the user wants to change the scale, we need to reset the window and redraw the table. And also highlight the tabs that must be played.
+6. Until now we have created all the required fundamentals that will be the modules of the GUI. After this, we configure our main window.
+
+
+## :white_check_mark: **HOW TO USE ?**
+Import the code and in the command line type <code> python scale_chart_code.py> </code>
+
+## :chart_with_upwards_trend: **ADVATANGES OF THE INTERFACE**
+* It will be  easy way to create chromatic scales (without typing them explicitly). 
+* We can play any scale we want to without having to google it all the time. 
+* It will be very useful in teaching students in musical school. 
+* Easy understanding and  learning of musical instruments is possible through this project.
+* Common people can learn any musical instrument without attending any coaching or workshops.
+* It will help to produce quality music.
+* Combining music with high end programming technologies might help create a global impact on the music industry.
+
+## :key: **PREQUISITES**
+All the dependencies and required libraries are included in the file <code>requirements.txt</code> [See here](./requirements.txt)
+
+## :round_pushpin: **CODE OUTPUTS**
+<p align="center">
+  <img width="600" height="300" src="https://user-images.githubusercontent.com/36481036/135593785-f8abbb1e-03fb-4176-aab9-e6e5eeba9600.png">
+
+</p>
+
+
+<p align="center">
+  <img width="600" height="250" src="https://user-images.githubusercontent.com/36481036/135593790-730c662a-2926-4afb-a2f4-9a4bf7e27738.png">
+
+</p>
+
+<p align="center">
+  <img width="3000" height="300" src="https://user-images.githubusercontent.com/36481036/135742600-16311aaa-5a85-4612-8c41-e3927fbf22f2.gif">
+
+</p>
+
+## :bust_in_silhouette: **CREDITS & REFERENCES**
+* https://github.com/crawsome/GuitarScaleChart
+* https://tkdocs.com/
+* https://github.com/kevinadi/scales
+* https://giphy.com/
+
+**:sunglasses:** **CREATOR**- https://github.com/theshredbox
+
+
+
+
+

GUIScripts/Scale Chart For Musical Composition/Images/Screenshot (506).png

@@ -0,0 +1 @@
+[1008/214643.214:ERROR:file_io.cc(90)] ReadExactly: expected 36, observed 0

GUIScripts/Scale Chart For Musical Composition/Images/Screenshot (507).png

@@ -0,0 +1 @@
+tkinter==8.6.10

GUIScripts/Scale Chart For Musical Composition/README.md

@@ -0,0 +1,191 @@
+#python3
+import sys
+from tkinter import *
+from collections import OrderedDict
+
+
+# This program creates a guitar scale gui from grid elements, and fills them in color-coded appropriately.
+
+# Get Note name from a 0-11 INT
+def getnotename(tonename):
+    notedict = ['E ', 'F ', 'F#', 'G ', 'Ab',
+                'A ', 'Bb', 'B ', 'C ', 'Db', 'D ', 'Eb']
+    return notedict[tonename % 12]
+
+
+# Contains int offsets, based on note string, added for convenience, which
+# is simply offset relative to C.
+def getoffset_tonename(tonename):
+    scaleref = {
+        'E ': 0, 'F ': 1, 'F#': 2, 'G ': 3, 'Ab': 4, 'A ': 5, 'Bb': 6, 'B ': 7, 'C ': 8, 'Db': 9, 'D ': 10,
+                'Eb': 11}
+
+
+    return scaleref[tonename]
+
+
+# Return array that is rotated circular
+def rotate(l, n):
+    return l[-n:] + l[:-n]
+
+
+scales = OrderedDict([
+    ('Major', [0, 2, 2, 1, 2, 2, 2, 1]),
+    ('Natural minor', [0, 2, 1, 2, 2, 1, 2, 2]),
+    ('Harmonic minor', [0, 2, 1, 2, 2, 1, 3, 1]),
+    ('Melodic minor', [0, 2, 1, 2, 2, 2, 2, 2]),
+    ('Dorian mode', [0, 2, 1, 2, 2, 2, 1, 2]),
+    ('Phrygian mode', [0, 1, 2, 2, 2, 1, 2, 2]),
+    ('Lydian mode', [0, 2, 2, 2, 1, 2, 2, 1]),
+    ('Mixolydian mode', [0, 2, 2, 1, 2, 2, 1, 2]),
+    ('Locrian mode', [0, 1, 2, 2, 1, 2, 2, 2]),
+    ('Ahava raba mode', [0, 1, 3, 1, 2, 1, 2, 2]),
+    ('Minor pentatonic', [0, 3, 2, 2, 3, 2]),
+    ('Pentatonic', [0, 2, 2, 3, 2, 3]),
+    ('Blues', [0, 3, 2, 1, 1, 3]),
+    ('5 chord', [0, 7]),
+    ('Major chord', [0, 4, 3]),
+    ('Minor chord', [0, 3, 4]),
+    ('Diminished chord', [0, 3, 3]),
+    ('Augmented chord', [0, 4, 4]),
+    ('Sus2 chord', [0, 2, 5]),
+    ('Sus4 chord', [0, 5, 2]),
+    ('Maj7 chord', [0, 4, 3, 4]),
+    ('min7 chord', [0, 3, 4, 3]),
+    ('7 chord', [0, 4, 3, 3]),
+    ('min7b5 chord', [0, 3, 3, 4]),
+    ('dim7 chord', [0, 3, 3, 3]),
+    ('9 chord', [0, 4, 3, 3, 4]),
+    ('Maj9 chord', [0, 4, 3, 4, 3]),
+    ('m9 chord', [0, 3, 4, 3, 4]),
+    ('11 chord', [0, 4, 3, 3, 4, 3]),
+    ('Maj11 chord', [0, 4, 3, 4, 3, 3]),
+    ('min11 chord', [0, 3, 4, 3, 4, 3]),
+])
+
+# returns a scale of 16 notes, from the key tonic + 24
+
+
+def makescale(keyroot, keyopt):
+    keywheel = []
+    keywheel.extend(scales[keyopt])
+    filler = 0
+    # fill array with 16 notes relevant to key and option.
+    ourscale = []
+    lenvar = len(keywheel)  # of notes we use (2 octaves of key notes)
+    for inte in range(lenvar):
+        filler += keywheel[inte % len(keywheel)]
+        ourscale.append(int(filler + getoffset_tonename(keyroot)))
+    return ourscale
+
+
+# fetches a default scale
+ourscale = makescale('E ', 'Major')
+
+# Used for note offsets
+e = 0
+
+# high e = (e+4), b = (e-1), g = (e+7), d = (e+2),a = (e+9), low e = (e+4)
+# added to each string to offset and identify the notes.
+offsetArray = [e, e + 7, e + 3, e + 10, e + 5, e]
+
+# default e Major
+chartgui = Tk()
+
+# our callback variables that change when menu options are selected
+variable = StringVar(chartgui)
+variable.set('E ')
+variable2 = StringVar(chartgui)
+variable2.set('Major')
+
+
+# variable3 = StringVar(chartgui)
+# variable3.set('View 1')
+
+
+# for clearing all our values, used for the "Reset" button.
+def resettable():
+    print("Tried to reset!")
+    for i in range(0, 25):
+        for gss in range(0, 6):
+            Label(chartgui, text=getnotename(i + offsetArray[gss]), bg='tan').grid(
+                row=gss + 2, column=i + 1, padx=0, pady=0)
+
+
+# redraw our whole scale, the action for the "Apply" button
+def applyit(val):
+    print("Trying to apply!")
+    # print("var1 = %s"%variable.get())
+    # print("var2 = %s"%variable2.get())
+    # print("var3 = %s"%variable3.get())
+    ourtonic = str(variable.get())
+    ourkey = str(variable2.get())
+    print(ourtonic)
+    print(ourkey)
+
+    ourscale = makescale(ourtonic, ourkey)
+    print(ourscale)
+    ournotes = []
+
+    for notes in ourscale:
+        ournotes.append(getnotename(notes))
+
+    print (ournotes)
+
+    # draw our whole scale
+    for i in range(0, 25):
+        for gss in range(0, 6):
+            start = offsetArray[gss]
+
+            # draw lawngreen for roots
+            if ourtonic == getnotename(i + start % 12):
+                Label(
+                    chartgui, text=getnotename(i + start), bg='lawngreen').grid(row=gss + 2, column=i + 1,
+                                                                          padx=0, pady=0)
+            # draw cyan for notes in the scale
+            elif getnotename(i + start) in ournotes:
+                Label(
+                    chartgui, text=getnotename(i + start), bg='cyan').grid(row=gss + 2, column=i + 1,
+                                                                             padx=0, pady=0)
+            # only write notename
+            else:
+                Label(chartgui, text=getnotename(i + start), bg='tan').grid(
+                    row=gss + 2, column=i + 1, padx=0, pady=0)
+
+
+if __name__ == "__main__":
+
+    chartgui.geometry('700x300+400+300')
+    chartgui.title('Guitarex- Playing Made Easier ')
+    chartgui.configure(bg= 'tan')
+    ourx = 40
+    oury = 20
+    chartgui.iconbitmap(r'C:\Users\Aryan\Downloads\IMG_20200108_094316_201.jpg')
+
+    # For our fret (column) labels on top and bottom
+    for i in range(0, 25):
+        Label(chartgui, text=i, font='boulder', bg='tan').grid(
+            row=0, column=i + 1, padx=0, pady=10)
+        Label(chartgui, text=i, font='boulder', bg='tan').grid(
+            row=9, column=i + 1, padx=0, pady=10)
+
+    # For our string (row) labels
+    stringarray = ['E', 'B', 'G', 'D', 'A', 'E']
+    for gss in range(0, 6):
+        Label(chartgui, text=stringarray[gss], font="comicsans", bg='tan').grid(
+            row=gss + 2, column=0, padx=10, pady=0)
+
+    print(ourscale)
+
+    # draw our whole scale
+    applyit("")
+
+    keymenu = OptionMenu(
+        chartgui, variable, 'E ', 'F ', 'F#', 'G ', 'Ab', 'A ', 'Bb', 'B ', 'C ', 'Db', 'D ',
+                         'Eb', command=applyit).place(x=ourx * 4, y=oury * 13)
+    scalemenu = OptionMenu(chartgui, variable2, *scales.keys(), command=applyit).place(
+        x=ourx * 6, y=oury * 13)
+    resetbutton = Button(chartgui, text=' Reset ', command=resettable).place(
+        x=ourx * 10, y=oury * 13)
+
+    chartgui.mainloop()