def startScoreFollower(self):
environLocal.printDebug("startScoreFollower starting")
self.button2 = tkinter.Button(self.master,
text="START SF",
width=self.sizeButton,
command=self.startScoreFollower,
state='disable',
bg='green')
self.button2.grid(row=5, column=3)
scNotes = self.scorePart.flat.notesAndRests
ScF = scoreFollower.ScoreFollower(scoreStream=scNotes)
ScF.show = False
ScF.plot = False
ScF.useMic = True
ScF.seconds_recording = 6.0
ScF.useScale = scale.ChromaticScale('C4')
ScF.begins = True
ScF.countdown = 0
self.firstTimeSF = True
self.stop = False
# decision of lastNotePosition taking into account the beginning of the first displayed page
ScF.lastNotePosition = self.beginningPages[self.currentLeftPage - 1]
ScF.startSearchAtSlot = self.beginningPages[self.currentLeftPage - 1]
ScF.result = False
self.textVar3.set('Start playing!')
self.scoreFollower = ScF
#parameters for the thread 2
self.dummyQueue = queue.Queue()
self.sampleQueue = queue.Queue()
self.dummyQueue2 = queue.Queue()
self.sampleQueue2 = queue.Queue()
self.firstAnalysis = True
self.continueScoreFollower()
def runScoreFollower(
self,
plot=False,
useMic=False,
seconds=15.0,
useScale=None,
):
'''
The main program. It runs the 'repeatTranscription' until the
performance ends.
If `useScale` is none, then it uses a scale.ChromaticScale
'''
if useScale is None:
useScale = scale.ChromaticScale('C4')
self.seconds_recording = seconds
self.useMic = useMic
self.useScale = useScale
self.result = False
while self.result is False:
self.result = self.repeatTranscription()
# if plot is True:
# try:
# import matplotlib.pyplot # for find
# except ImportError:
# raise AudioSearchException('Cannot plot without matplotlib installed.')
#
# matplotlib.pyplot.plot(listplot)
# matplotlib.pyplot.show()
environLocal.printDebug('* END')
def runTranscribe(show=True, plot=True, useMic=True,
seconds=20.0, useScale=None, saveFile=True):
'''
runs all the methods to record from audio for `seconds` length (default 10.0)
and transcribe the resulting melody returning a music21.Score object
if `show` is True, show the stream.
if `plot` is True then a Tk graph of the frequencies will be displayed.
if `useMic` is True then use the microphone. If False it will load the file of `saveFile`
or the default temp file to run transcriptions from.
a different scale besides the chromatic scale can be specified by setting `useScale`.
See :ref:`moduleScale` for a list of allowable scales. (or a custom one can be given).
Microtonal scales are totally accepted, as are retuned scales where A != 440hz.
if `saveFile` is False then then the recorded audio is saved to disk. If
set to `True` then `environLocal.getRootTempDir() + os.path.sep + 'ex.wav'` is
used as the filename. If set to anything else then it will use that as the
filename.
'''
from music21 import audioSearch as audioSearchBase
if useScale is None:
useScale = scale.ChromaticScale('C4')
#beginning - recording or not
if saveFile != False:
if saveFile == True:
WAVE_FILENAME = environLocal.getRootTempDir() + os.path.sep + 'ex.wav'
else:
WAVE_FILENAME = saveFile
else:
WAVE_FILENAME = False
# the rest of the score
if useMic is True:
freqFromAQList = audioSearchBase.getFrequenciesFromMicrophone(length=seconds, storeWaveFilename=WAVE_FILENAME)
else:
freqFromAQList = audioSearchBase.getFrequenciesFromAudioFile(waveFilename=WAVE_FILENAME)
detectedPitchesFreq = audioSearchBase.detectPitchFrequencies(freqFromAQList, useScale)
detectedPitchesFreq = audioSearchBase.smoothFrequencies(detectedPitchesFreq)
(detectedPitchObjects, listplot) = audioSearchBase.pitchFrequenciesToObjects(detectedPitchesFreq, useScale)
(notesList, durationList) = audioSearchBase.joinConsecutiveIdenticalPitches(detectedPitchObjects)
myScore, unused_length_part = audioSearchBase.notesAndDurationsToStream(notesList, durationList, removeRestsAtBeginning=True)
if show == True:
myScore.show()
if plot == True:
try:
import matplotlib.pyplot # for find
except ImportError:
raise audioSearchBase.AudioSearchException("Cannot plot without matplotlib installed.")
matplotlib.pyplot.plot(listplot)
matplotlib.pyplot.show()
environLocal.printDebug("* END")
return myScore
def scalar_inversion(
original_stream: stream.Stream,
inversion_axis: Union[str, pitch.Pitch],
reference_scale: scale.ConcreteScale = scale.ChromaticScale("C"),
in_place: bool = False,
) -> stream.Stream:
"""Performs a scale-space inversion on a stream.
Args:
original_stream: The stream to process.
inversion_axis: The pitch around which to execute the inversion.
reference_scale: Optional; The scale to use as reference. By default, the chromatic scale is
used.
in_place: Optional; If true, the operation is done in place on the original stream. By
default, a new Stream object is returned.
Returns:
The inverted stream.
"""
# Check if stream is to be processed in place
post_stream = original_stream if in_place else copy.deepcopy(
original_stream)
# Check if inversion_axis is Pitch
if isinstance(inversion_axis, str):
inversion_axis = pitch.Pitch(inversion_axis)
# Invert all individual pitches
for pitch_ in post_stream.pitches:
distance_from_axis = _get_scale_distance(inversion_axis, pitch_,
reference_scale)
_transpose_pitch_in_scale_space(pitch_, distance_from_axis * -2,
reference_scale)
return post_stream
def scalar_transposition(
original_stream: stream.Stream,
steps: int,
reference_scale: scale.ConcreteScale = scale.ChromaticScale("C"),
in_place: bool = False,
) -> stream.Stream:
"""Performs scale-space transpotition on a stream.
Transposes all notes in a stream by a specified amount of scale steps in a specific scale space.
Args:
original_stream: The stream to process.
steps: The amount of steps to transpose. Positive values transpose up, negative values
transpose down.
reference_scale: Optional; The scale to use as reference. By default, the chromatic scale
is used.
in_place: Optional; If true, the operation is done in place on the original stream. By
default, a new Stream object is returned.
Returns:
The transposed stream.
"""
# Check if stream is to be processed in place
post_stream = original_stream if in_place else copy.deepcopy(
original_stream)
# Transpose all individual pitches
for pitch_ in post_stream.pitches:
_transpose_pitch_in_scale_space(pitch_, steps, reference_scale)
return post_stream
def run(self):
self.myScore = transcriber.runTranscribe(
show=self.show,
plot=False,
useMic=True,
seconds=self.seconds,
useScale=scale.ChromaticScale('C4'),
saveFile=self.saveFile)
self.queue.put(1)
def get_all_scales():
pitches = scale.ChromaticScale('A').pitches
major_scales = [scale.MajorScale(pitch) for pitch in pitches]
minor_scales = [scale.MinorScale(pitch) for pitch in pitches]
scales = parse_and_format_scales(major_scales)
scales.extend(parse_and_format_scales(minor_scales))
return scales
def runGame():
useScale = scale.ChromaticScale('C4')
roundNumber = 0
good = True
gameNotes = []
print("Welcome to the music21 game!")
print("Rules:")
print(
"The computer generates a note (and it will play them in the future).")
print("The player has to play all the notes from the beginning.")
time.sleep(2)
print("3, 2, 1 GO!")
nameNotes = ["A", "B", "C", "D", "E", "F", "G"]
while (good == True):
randomNumber = random.randint(0, 6)
octaveNumber = 4 # I can put a random number here...
fullNameNote = "%s%d" % (nameNotes[randomNumber], octaveNumber)
gameNotes.append(note.Note(fullNameNote))
roundNumber = roundNumber + 1
print("ROUND %d" % roundNumber)
print("NOTES UNTIL NOW: (this will not be shown in the final version)")
for k in range(len(gameNotes)):
print(gameNotes[k].fullName)
seconds = 2 * roundNumber + 2
freqFromAQList = base.getFrequenciesFromMicrophone(
length=seconds, storeWaveFilename=None)
detectedPitchesFreq = base.detectPitchFrequencies(
freqFromAQList, useScale)
detectedPitchesFreq = base.smoothFrequencies(detectedPitchesFreq)
(detectedPitchObjects,
unused_listplot) = base.pitchFrequenciesToObjects(
detectedPitchesFreq, useScale)
(notesList, unused_durationList
) = base.joinConsecutiveIdenticalPitches(detectedPitchObjects)
j = 0
i = 0
while i < len(notesList) and j < len(gameNotes) and good == True:
if notesList[i].name == "rest":
i = i + 1
elif notesList[i].name == gameNotes[j].name:
i = i + 1
j = j + 1
else:
print("WRONG NOTE! You played", notesList[i].fullName,
"and should have been", gameNotes[j].fullName)
good = False
if good == True and j != len(gameNotes):
good = False
print("YOU ARE VERY SLOW!!! PLAY FASTER NEXT TIME!")
if good == False:
print("GAME OVER! TOTAL ROUNDS: %d" % roundNumber)
def __init__(self):
self.useScale = scale.ChromaticScale('C4')
self.round = 0
self.good = True
self.gameNotes = []
print "Welcome to the music21 game!"
print "Rules:"
print "Two players: the first one plays a note. \nThe second one has to play the first note and a new one."
print "Continue doing the same until one fails."
# time.sleep(2)
print "3, 2, 1 GO!"
def prepareThresholds(useScale=None):
# noinspection PyShadowingNames
'''
returns two elements. The first is a list of threshold values
for one octave of a given scale, `useScale`,
(including the octave repetition) (Default is a ChromaticScale).
The second is the pitches of the scale.
A threshold value is the fractional part of the log-base-2 value of the
frequency.
For instance if A = 440 and B-flat = 460, then the threshold between
A and B-flat will be 450. Notes below 450 should be considered As and those
above 450 should be considered B-flats.
Thus the list returned has one less element than the number of notes in the
scale + octave repetition. If useScale is a ChromaticScale, `prepareThresholds`
will return a 12 element list. If it's a diatonic scale, it'll have 7 elements.
>>> pitchThresholds, pitches = audioSearch.prepareThresholds(scale.MajorScale('A3'))
>>> for i in range(len(pitchThresholds)):
... print(f'{pitches[i]} < {pitchThresholds[i]:.2f} < {pitches[i + 1]}')
A3 < 0.86 < B3
B3 < 0.53 < C#4
C#4 < 0.16 < D4
D4 < 0.28 < E4
E4 < 0.45 < F#4
F#4 < 0.61 < G#4
G#4 < 1.24 < A4
'''
if useScale is None:
useScale = scale.ChromaticScale('C4')
scPitches = useScale.pitches
scPitchesRemainder = []
for p in scPitches:
pLog2 = math.log2(p.frequency)
scPitchesRemainder.append(math.modf(pLog2)[0])
scPitchesRemainder[-1] += 1
scPitchesThreshold = []
for i in range(len(scPitchesRemainder) - 1):
scPitchesThreshold.append(
(scPitchesRemainder[i] + scPitchesRemainder[i + 1]) / 2)
return scPitchesThreshold, scPitches
def testChromaticScaleA(self):
cs = scale.ChromaticScale('c4')
self.assertEqual(
self.pitchOut(cs.pitches),
'[C4, C#4, D4, E-4, E4, F4, F#4, G4, A-4, A4, B-4, B4, C5]')
