rhL%SrSSKJr /SQrSSKrSSKrSSKrSSKrSSKrSSK r SSK J r SSK J r SSK Jr SSK Jr SS K Jr SS K Jr SS K Jr SS K Jr SS K Jr SSK Jr SSKJr SSKJr \R2"S5rSrSrSrSrS.SjrSr S/Sjr!S.Sjr"S0Sjr#S1Sjr$S2Sjr%S.Sjr&SSS .S3S!jjr'S"r(S#r)S4S$jr*S5S%jr+S/S&jr,"S'S(\RZ5r."S)S*\ R^5r0/r1S+\2S,'\3S-:XaSSK r \ Rh"\05 gg)6z Base routines used throughout audioSearching and score-following. Requires numpy and matplotlib. Installing scipy makes the process faster and more accurate using FFT convolve. ) annotations) transcriber recording scoreFollower histogramautocorrelationFunctionprepareThresholds interpolationnormalizeInputFrequencypitchFrequenciesToObjectsgetFrequenciesFromMicrophonegetFrequenciesFromAudioFile"getFrequenciesFromPartialAudioFiledetectPitchFrequenciessmoothFrequenciesjoinConsecutiveIdenticalPitchesquantizeDurationquarterLengthEstimationnotesAndDurationsToStreamdecisionProcessAudioSearchExceptionN)cast)base) environment) exceptions21)features)metadata)note)pitch)scale)stream)r)r audioSearchiiDc~[U5n[U5nX#- U- n/n[[U55HnUR S5 M UH/nSnXcXt--:aUS- nXcXt--:aMXWS- ==S- ss'M1 U/nSn[[U55HnUR X7U--5 US- nM XX4$)a Partition the list in `data` into a number of bins defined by `bins` and return the number of elements in each bin and a set of `bins` + 1 elements where the first element (0) is the start of the first bin, the last element (-1) is the end of the last bin, and every remaining element (i) is the dividing point between one bin and another. >>> data = [1, 1, 4, 5, 6, 0, 8, 8, 8, 8, 8] >>> outputData, bins = audioSearch.histogram(data, 8) >>> print(outputData) [3, 0, 0, 1, 1, 1, 0, 5] >>> bins [0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0] >>> print([int(b) for b in bins]) [0, 1, 2, 3, 4, 5, 6, 7, 8] >>> outputData, bins = audioSearch.histogram(data, 4) >>> print(outputData) [3, 1, 2, 5] >>> print([int(b) for b in bins]) [0, 2, 4, 6, 8] r)maxminrangeintappend) databinsmaxValueminValue lengthEachBin containericount binsLimitss V/home/james-whalen/.local/lib/python3.13/site-packages/music21/audioSearch/__init__.pyrrEs04yH4yH(D0MI 3t9  U222 QJEU222!)!  J E 3t9 (]%::;     cS[R=n;a[SSU3-5eSSKnSn[R "5 [R "S[5 [R "S[5 SSK J n SSS5 URU5nU"XSSS 2S S 9n[U5S -nXVSnUR!U5nUR#US:5Sn[U5S:XaS n U $USn UR%XZS5U -n ['X[5n X- n U $!,(df  N=f![a% [R"S5 URnNf=f)a Converts the temporal domain into a frequency domain. To do that, it uses the autocorrelation function, which finds periodicities in the signal in the temporal domain and, consequently, finds the frequency in each instant of time. >>> import wave >>> import numpy # you need to have numpy, scipy, and matplotlib installed to use this >>> wv = wave.open(str(common.getSourceFilePath() / ... 'audioSearch' / 'test_audio.wav'), 'r') >>> data = wv.readframes(1024) >>> samples = numpy.frombuffer(data, dtype=numpy.int16) >>> finalResult = audioSearch.autocorrelationFunction(samples, 44100) >>> wv.close() >>> print(finalResult) 143.6276... numpyz+Cannot run autocorrelationFunction without z.numpy installed (scipy recommended). Missing rNignore) fftconvolvez0Running convolve without scipy -- will be slowerfull)mode )r_missingImportrr6warningscatch_warnings simplefilter ImportWarningDeprecationWarning scipy.signalr8 ImportErrorwarnconvolvearraylendiffwhereargmaxr ) recordedSignalrecordSampleRateInbmir6rG correlationlengthCorrelation differencepositiveDifferences finalResult beginningpeakvertexs r3rrrsi*$---3." 9>seD EF FH "  $ $ &  ! !(M :  ! !(,> ? < '[[0N>$B$+?fMKK(A-01KK(J++j1n5a8 1$  (* ||K 34y@{1(1 /' & " HI>>"s/D1=D D1 D.*D1.D11,E E cUc[R"S5nURn/nUHKn[R"UR 5nUR [R"U5S5 MM US==S- ss'/n[[U5S- 5H!nUR X&X&S--S- 5 M# XQ4$)a 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 C4rr9r$r<) r ChromaticScalepitchesmathlog2 frequencyr)modfr'rI)useScale scPitchesscPitchesRemainderppLog2scPitchesThresholdr0s r3r r s>''-  I  !++&!!$))E"21"56ra 3)*Q. /!!#5#8;MRSe;T#TXY"YZ0  ((r4cUS[U5S- 4;aU$XS- XS-- XS- SX-- XS--- nUS-U-nU$)a Interpolation for estimating the true position of an inter-sample maximum when nearby samples are known. Correlation is a vector and peak is an index for that vector. Returns the x coordinate of the vertex of that parabola. >>> import numpy >>> f = [2, 3, 1, 6, 4, 2, 3, 1] >>> peak = int(numpy.argmax(f)) >>> peak # f[3] is 6, which is the max. 3 >>> audioSearch.interpolation(f, peak) 3.21428571... rr$@g?)rI)rPrVrWs r3r r st$ 3{#a'(( (#k(&;;1Hk&7 77+Qh:OOQF c\D F Mr4c`UcUcUbUc [S5eUc [5up[R"U5n[R"U5upE[ U5n[ [U55H_nXnXG:dM[R"X&5nUS- Ul [R"[X&55n U RU4s $ [R"US5nUS- Ul Xl[R"[US55n U RU4$)a Takes in an inputFrequency, a set of threshold values, and a set of allowable pitches (given by prepareThresholds) and returns a tuple of the normalized frequency and the pitch detected (as a :class:`~music21.pitch.Pitch` object) It will convert the frequency to be within the range of the default frequencies (usually C4 to C5), but the pitch object will have the correct octave. >>> audioSearch.normalizeInputFrequency(441.72) (440.0, ) If you will be doing this often, it's best to cache your thresholds and pitches by running `prepareThresholds` once first: >>> thresholds, pitches = audioSearch.prepareThresholds(scale.ChromaticScale('C4')) >>> for fq in [450, 510, 550, 600]: ... print(audioSearch.normalizeInputFrequency(fq, thresholds, pitches)) (440.0, ) (523.25113..., ) (277.18263..., ) (293.66476..., ) z[Cannot normalize input frequency if thresholds are given and pitches are not, or vice-versar9)rr r\r]r_r(r'rIcopydeepcopyoctaverPitchstrr^inputFrequency) inputPitchFrequency thresholdsr[inputPitchLog2 remainderrmr0 threshold returnPitch name_notes r3r r s2   3  "w" /0 0 1 3YY23N))N3Y [F 3z? #M  -- 3K!'!K  C O4I&& 3 3$-- ,K!K!4 C ,-I    ++r4cUc[R"S5n/n[U5up4[[ U55H&nXn[ XcU5upxUR U5 M( /n SnU[ U5S- :aX%Rn Un Sn U[ U5S- :aNX%RU :Xa<XUR-n US-nU[ U5S- :aX%RU :XaM<[XU - - 5n [X[- 5H4n XX-S- lU R X+U -S- R5 M6 U[ U5S- :aMX)4$)a Takes in a list of detected pitch frequencies and returns a tuple where the first element is a list of :class:~`music21.pitch.Pitch` objects that best match these frequencies and the second element is a list of the frequencies of those objects that can be plotted for matplotlib TODO: only return the former. The latter can be generated in other ways. >>> readPath = common.getSourceFilePath() / 'audioSearch' / 'test_audio.wav' >>> freqFromAQList = audioSearch.getFrequenciesFromAudioFile(waveFilename=readPath) >>> detectedPitchesFreq = audioSearch.detectPitchFrequencies( ... freqFromAQList, useScale=scale.ChromaticScale('C4')) >>> detectedPitchesFreq = audioSearch.smoothFrequencies(detectedPitchesFreq) >>> (detectedPitchObjects, listPlot) = audioSearch.pitchFrequenciesToObjects( ... detectedPitchesFreq, useScale=scale.ChromaticScale('C4')) >>> [str(p) for p in detectedPitchObjects] ['A5', 'A5', 'A6', 'D6', 'D4', 'B4', 'A4', 'F4', 'E-4', 'C#3', 'B3', 'B3', 'B3', 'A3', 'G3',...] rYrr$) r MajorScaler r'rIr r)namermroundr^)detectedPitchesFreqr`detectedPitchObjectsrrr[r0rq unused_freq pitch_namelistPlotrzhold tot_octavejs r3r r -s{*##D)-h7Z 3*+ ,14"9:M[b"c ##J/- H A c&'!+ +#&++ #*+a//4H4K4P4PTX4X#1&=&D&DDJAA#*+a//4H4K4P4PTX4X:T23 qxA8BA . 5 OO0A>HH I! c&'!+ + ))r4cZS[R;a [S5eSSKn[R S5 [ R"UU[S9n[R S5 /nUH;nURXRRS9nUR[U[55 M= U$) z records for length (=seconds) a set of frequencies from the microphone. If storeWaveFilename is not None, then it will store the recording on disk in a wave file. Returns a list of frequencies detected. TODO -- find a way to test or at least demo r6z?Cannot run getFrequenciesFromMicrophone without numpy installedrNz* start recording)seconds storeFilerecordChunkLengthz* stop recordingdtype)rr>rr6 environLocal printDebugrsamplesFromRecordingaudioChunkLength frombufferint16r)rrecordSampleRate)lengthstoreWaveFilenamer6storedWaveSampleListfreqFromAQListr*sampless r3r r ]s$%%%" MO O/0$99&DUL\^./N$""4{{";5g?OPQ% r4c ZS[R;a [S5eSSKn/n[R S5 [ R"[U5S5n[[UR5[- 55H)nUR[5nURU5 M+ /nUHDnUR!XQR"S 9nUR[%['U[(555 MF UR+5 U$![a [SUS35ef=f) a| gets a list of frequencies from a complete audio file. Each sample is a window of audioSearch.audioChunkLength long. >>> audioSearch.audioChunkLength 1024 >>> readPath = common.getSourceFilePath() / 'audioSearch' / 'test_audio.wav' >>> freq = audioSearch.getFrequenciesFromAudioFile(waveFilename=readPath) >>> print(freq) [143.627..., 99.083..., 211.004..., 4700.313..., ...] r6z>Cannot run getFrequenciesFromAudioFile without numpy installedrNz* reading entire file from diskr Cannot open  for reading, does not existr)rr>rr6rrwaveopenroIOErrorr'r( getnframesr readframesr)rrfloatrrclose) waveFilenamer6rwvr0r*rrs r3rr|s$%%%" LN N=>^ YYs<(# . 3r}})99: ;}}-.##D)<N$""4{{";e$;GEU$VWX%HHJ  ^"\,?[#\]]^s DD*cfS[R;a [S5eSSKnUS:Xa[R 5S- n[ U[R5(a [U5n[ U[5(aUn[R"US5nO[[RU5n/n[RS 5 [![#[$R&"U[(-[*- 555HGnU[*-nX%R-5:dM!UR/[*5nUR1U5 MI /n UH;nUR3XR4S 9n U R1[7U [(55 M= Un XU 4$![a [SUS 35ef=f) a* It calculates the fundamental frequency at every instant of time of an audio signal extracted either from the microphone or from an already recorded song. It uses a period of time defined by the variable "length" in seconds. It returns a list with the frequencies, a variable with the file descriptor, and the end sample position. >>> #_DOCS_SHOW readFile = 'pachelbel.wav' >>> sp = common.getSourceFilePath() #_DOCS_HIDE >>> readFile = sp / 'audioSearch' / 'test_audio.wav' #_DOCS_HIDE >>> fTup = audioSearch.getFrequenciesFromPartialAudioFile(readFile, length=1.0) >>> frequencyList, pachelbelFileHandle, currentSample = fTup >>> for frequencyIndex in range(5): ... print(frequencyList[frequencyIndex]) 143.627... 99.083... 211.004... 4700.313... 767.827... >>> print(currentSample) # should be near 44100, but probably not exact 44032 Now read the next 1 second: >>> fTup = audioSearch.getFrequenciesFromPartialAudioFile(pachelbelFileHandle, length=1.0, ... startSample=currentSample) >>> frequencyList, pachelbelFileHandle, currentSample = fTup >>> for frequencyIndex in range(5): ... print(frequencyList[frequencyIndex]) 187.798... 238.263... 409.700... 149.958... 101.989... >>> print(currentSample) # should be exactly double the previous 88064 r6zECannot run getFrequenciesFromPartialAudioFile without numpy installedrNtempztemp.wavrrrz+* reading file from disk a part of the songr)rr>rr6rgetRootTempDir isinstancepathlibPathrorrrr Wave_readrr'r(r\floorrrrrr)rrr) waveFilenameOrHandler startSampler6r waveHandlerr0r*rr endSamples r3rrsP$%%%" SU Uv%+::? IJ 3tzz&+;";>N"NOP Q!$44 ..0 0(()9:D ' ' - R N$""4{{";5g?OPQ%I  22+ b&l^C_'`a a bs FF0cUc[R"S5n[U5up#/n[[ U55H0nXn[ XbU5upxUR UR5 M2 U$)a$ Detects the pitches of the notes from a list of frequencies, using thresholds which depend on the useScale option. If useScale is None, the default value is the Major Scale beginning C4. Returns the frequency of each pitch after normalizing them. >>> freqFromAQList=[143.627689055, 99.0835452019, 211.004784689, 4700.31347962, 2197.9431119] >>> cMaj = scale.MajorScale('C4') >>> pitchesList = audioSearch.detectPitchFrequencies(freqFromAQList, useScale=cMaj) >>> for i in range(5): ... print(int(round(pitchesList[i]))) 147 98 220 4699 2093 rY)r ryr r'rIr r)r^) rr`rrr[r|r0rqr~rs r3rrsw(##D)-h7Z 3~& ',/"9:M[b"c "":#7#78( r4F) smoothLevelsinPlacec US:a [S5e[U5nX:a[SUSUS35eUnU(aUVs/sHn[U5PM nnO/[R"U5Vs/sHn[U5PM nnSnSn[ U5Hn XvU -nXUS- U - -nM Xq- nX- n[ U5Hn U [ [ R"US- 55:a[ U5Xi'M8X[ [ R"US- 55- S- :a[ U5Xi'MrSn [ U5H/n XX-[ [ R"US- 55- - n M1 X- Xi'M UVs/sHn[ [U55PM n nU(dU $[ [U55H n XX 'M gs snfs snfs snf) a Smooths the shape of the signal to avoid false detections in the fundamental frequency. Takes in a list of ints or floats. The second pitch below is certainly too low. It will be smoothed out: >>> inputPitches = [440, 220, 440, 440, 442, 443, 441, 470, 440, 441, 440, ... 442, 440, 440, 440, 397, 440, 440, 440, 442, 443, 441, ... 440, 440, 440, 440, 440, 442, 443, 441, 440, 440] >>> result = audioSearch.smoothFrequencies(inputPitches) >>> result [409, 409, 409, 428, 435, 438, 442, 444, 441, 441, 441, 441, 434, 433, 432, 431, 437, 438, 439, 440, 440, 440, 440, 440, 440, 441, 441, 441, 440, 440, 440, 440] Original list is unchanged: >>> inputPitches[1] 220 Different levels of smoothing have different effects. At smoothLevel=2, the isolated 220hz sample is pulling down the surrounding samples: >>> audioSearch.smoothFrequencies(inputPitches, smoothLevels=2)[:5] [330, 275, 358, 399, 420] Doing this enough times will smooth out a lot of inconsistencies. >>> audioSearch.smoothFrequencies(inputPitches, smoothLevels=28)[:5] [432, 432, 432, 432, 432] If inPlace is True then the list is modified in place and nothing is returned: >>> audioSearch.smoothFrequencies(inputPitches, inPlace=True) >>> inputPitches[:5] [409, 409, 409, 428, 435] Note that `smoothLevels=1` is the baseline that does nothing: >>> audioSearch.smoothFrequencies(inputPitches, smoothLevels=1) == inputPitches True And less than 1 raises a ValueError: >>> audioSearch.smoothFrequencies(inputPitches, smoothLevels=0) Traceback (most recent call last): ValueError: smoothLevels must be >= 1 There cannot be more smoothLevels than input frequencies: >>> audioSearch.smoothFrequencies(inputPitches, smoothLevels=40) Traceback (most recent call last): ValueError: There cannot be more smoothLevels (40) than inputPitches (32) Note that the system runs on O(smoothLevels * len(frequenciesList)), so additional smoothLevels can be costly on a large set. This function always returns a list of ints -- rounding to the nearest hertz (you did want it smoothed right?) * Changed in v6: inPlace defaults to False (like other music21 functions) and if done in Place, returns nothing. smoothLevels and inPlace became keyword only. r$zsmoothLevels must be >= 1z#There cannot be more smoothLevels (z) than inputPitches ()grgN) ValueErrorrIrrkr'r(r\rceilr{) frequencyListrrnumFreqsdpffr|rUendsr0changerouts r3rrsNa455=!H1,?TU]T^^_ `   C145AuQx5153@AuQx@I D < A 66 (Q,*:;;!(I  D 8_ s4::lS012 2%(^  " C ,*< =>>B B%(Y  "F<(aec$**\TWEW:X6Y.YZZ)%+%:  ".AA-@c%(m-@CA  s=)*A"vM +A6@0BsG1GGcSnXSlSnSnSnSnSnSn/n/n U[U5:GaXRn U[U5:aXUR:XawUS-nUS:aDSnUS:a:U RU5 US-nUR[R"55 SnUS-nU[U5:aXUR:XaMwU(aIU RU5 US-n[R "5n XS- U lURU 5 OXC-nSnSnUS-nU[U5:aGMX4$)a[ takes a list of equally spaced :class:`~music21.pitch.Pitch` objects and returns a tuple of two lists, the first a list of :class:`~music21.note.Note` or :class:`~music21.note.Rest` objects (each of quarterLength 1.0) and a list of how many were joined together to make that object. N.B. the returned list is NOT a :class:`~music21.stream.Stream`. >>> readPath = common.getSourceFilePath() / 'audioSearch' / 'test_audio.wav' >>> freqFromAQList = audioSearch.getFrequenciesFromAudioFile(waveFilename=readPath) >>> chrome = scale.ChromaticScale('C4') >>> detectedPitchesFreq = audioSearch.detectPitchFrequencies(freqFromAQList, useScale=chrome) >>> detectedPitchesFreq = audioSearch.smoothFrequencies(detectedPitchesFreq) >>> (detectedPitches, listPlot) = audioSearch.pitchFrequenciesToObjects( ... detectedPitchesFreq, useScale=chrome) >>> len(detectedPitches) 861 >>> notesList, durationList = audioSearch.joinConsecutiveIdenticalPitches(detectedPitches) >>> len(notesList) 24 >>> print(notesList) [, , , , , , , , , , ...] >>> print(durationList) [71, 6, 14, 23, 34, 40, 27, 36, 35, 15, 17, 15, 6, 33, 22, 13, 16, 39, 35, 38, 27, 27, 26, 8] r=rFr$T)r^rIr)rRestNoter) r}REST_FREQUENCYrgoodbad valid_note total_notes total_rests notesList durationListfrns r3rrso@N(6% A D CJKKIL c&' ' ! $ . .#*++16M6W6W0W!8Dqy! "9 '',"-/K$$TYY[1AA#*++16M6W6W0W     %%/K A*q51AG   Q *C E? c&' '@  ""r4cUS-n/SQn/n[[U5S- 5H!nURXXS--S- 5 M# USn[[U55HnX#nX:dMXS-nM US- $)aN round an approximately transcribed quarterLength to a better one in music21. Should be replaced by a full-featured routine in midi or stream. See :meth:`~music21.stream.Stream.quantize` for more information on the standard music21 methodology. >>> audioSearch.quantizeDuration(1.01) 1.0 >>> audioSearch.quantizeDuration(1.70) 1.5 d)g9@gI@gY@gb@gi@gy@r$r<r)r'rIr))rtypicalLengthsrrr0 finalLengthrus r3rrsc\FCNJ 3~&* +>,~!e/DDIJ,!#K 3z? #M  (Q/K$  r4cr[R"U5nURS5 [US5up4[U5S- nX5[ U5:waUS- nX5[ U5:waMXEXES--S- nUS:XaSnS[ R "U5- nU[ R"SU5-nU$)a takes a list of lengths of notes (measured in audio samples) and tries to estimate what the length of a quarter note should be in this list. If mostRepeatedQuarterLength is another number, it still returns the estimated length of a quarter note, but chooses it so that the most common note in durationList will be the other note. See example 2: Returns a float -- and not an int. >>> durationList = [20, 19, 10, 30, 6, 21] >>> audioSearch.quarterLengthEstimation(durationList) 20.625 Example 2: suppose these are the inputted durations for a score where most of the notes are half notes. Show how long a quarter note should be: >>> audioSearch.quarterLengthEstimation(durationList, mostRepeatedQuarterLength=2.0) 10.3125 rg @r$rg?r<)rkr)rrIr%r\r]pow)rmostRepeatedQuarterLengthdlpdfr+r0qle binPositions r3rrs0 < BIIaL"c"IC C1 A &CH  E &CH  7Ta%[ C 'C A%$'!dii 9::K K( (C Jr4cp[R"5nUbH[RR U5nUR 5R Sn[X5nOUc [U5n[[U55HLn[XU- 5n XUl U(aXRS:XaM7URX5 SnMN [R"5n [R "5U lSU RlU R%SU5 Uc U [U54$X4$)a take a list of :class:`~music21.note.Note` objects or rests and an equally long list of how long each one lasts in terms of samples and returns a Stream using the information from quarterLengthEstimation and quantizeDurations. returns a :class:`~music21.stream.Score` object, containing a metadata object and a single :class:`~music21.stream.Part` object, which in turn contains the notes, etc. Does not run :meth:`~music21.stream.base.Stream.makeNotation` on the Score. >>> durationList = [20, 19, 10, 30, 6, 21] >>> n = note.Note >>> noteList = [n('C#4'), n('D5'), n('B4'), n('F#5'), n('C5'), note.Rest()] >>> s,lengthPart = audioSearch.notesAndDurationsToStream(noteList, durationList) >>> s.show('text') {0.0} {0.0} {0.0} {1.0} {2.0} {2.5} {4.0} {4.25} rrestFzAutomatic Music21 Transcription)r!PartrnativeMostCommonNoteQuarterLengthextractvectorrr'rIr quarterLengthrzr)ScorerMetadatatitleinsert) rrscNotesremoveRestsAtBeginningrp2fe mostCommonr0actualDurationscs r3rr0sH B  __ 8 8 AZZ\((+ %l? %l3 3|$ %),/C*?@%3! "&IL,=,=,G IIil #%* " & B##%BK9BKKIIa3r7{wr4cSnSnU[U5:aTU[XR5U:a6US-nUnU[U5:a U[XR5U:aM6[U5S:XaSn[R"USU- 5n [ [U55HnU[XR5n XR SUSR -:dMAX:dMH[R"X- 5U :dMf[R"X- 5n UnM U[XR5n U[U5:a X::a[RSU SU35 XR S:d[U5S:Xa[RS5 US-nOU S:a%US:XaUS- n[RS U <35 O^U S :a%US:XaUS- n[RS U <35 O3Ub.Ub+X:dX:a!US :aUS- n[RS 5 OSn[RS U SU SU/5 X4$)a Decides which of the given parts of the score has the best match with the recorded part of the song. If there is not a part of the score with a high probability to be the correct part, it starts a "countdown" in order stop the score following if the bad matching persists. In this case, it does not match the recorded part of the song with any part of the score. Inputs: partsList, contains all the possible parts of the score, sorted from the higher probability to be the best matching at the beginning to the lowest probability. notePrediction is the position of the score in which the next note should start. beginningData is a list with all the beginnings of the used fragments of the score to find the best matching. lastNotePosition is the position of the score in which the last matched fragment of the score finishes. Countdown is a counter of consecutive errors in the matching process. Outputs: Returns the beginning of the best matching fragment of score and the countdown. >>> scNotes = corpus.parse('luca/gloria').parts[0].flatten().notes.stream() >>> scoreStream = scNotes >>> sfp = common.getSourceFilePath() #_DOCS_HIDE >>> readPath = sfp / 'audioSearch' / 'test_audio.wav' #_DOCS_HIDE >>> freqFromAQList = audioSearch.getFrequenciesFromAudioFile(waveFilename=readPath) #_DOCS_HIDE >>> tf = 'test_audio.wav' >>> #_DOCS_SHOW freqFromAQList = audioSearch.getFrequenciesFromAudioFile(waveFilename=tf) >>> chrome = scale.ChromaticScale('C4') >>> detectedPitchesFreq = audioSearch.detectPitchFrequencies(freqFromAQList, useScale=chrome) >>> detectedPitchesFreq = audioSearch.smoothFrequencies(detectedPitchesFreq) >>> (detectedPitches, listPlot) = audioSearch.pitchFrequenciesToObjects( ... detectedPitchesFreq, useScale=chrome) >>> (notesList, durationList) = audioSearch.joinConsecutiveIdenticalPitches(detectedPitches) >>> transcribedScore, qle = audioSearch.notesAndDurationsToStream(notesList, durationList, ... scNotes=scNotes, qle=None) >>> hop = 6 >>> tn_recording = 24 >>> totScores = [] >>> beginningData = [] >>> lengthData = [] >>> for i in range(4): ... excerpt = scoreStream[i * hop + 1:i * hop + tn_recording + 1] ... scNotes = stream.Part(excerpt) ... name = str(i) ... beginningData.append(i * hop + 1) ... lengthData.append(tn_recording) ... scNotes.id = name ... totScores.append(scNotes) >>> listOfParts = search.approximateNoteSearch(transcribedScore.flatten().notes.stream(), ... totScores) >>> notePrediction = 0 >>> lastNotePosition = 0 >>> countdown = 0 >>> positionInList, countdown = audioSearch.decisionProcess( ... listOfParts, notePrediction, beginningData, lastNotePosition, countdown) >>> print(positionInList) 0 The countdown result is 1 because the song used is completely different from the score!! >>> print(countdown) 1 rr$g?z error ? z, g333333?z,Are you sure you are playing the right song?zExcessive distance? dist=r<zplaying in a not shown partz2****????**** DECISION PROCESS: dist from expected:zbeginning data: lastNotePos) rIr(idr\fabsr'matchProbabilityrr) partsListnotePrediction beginningDatalastNotePosition countdown firstNotePage lastNotePager0positiondistpositionBeginningDatas r3rrrsOR AH c)n s9 " -c),//.B C \ * *cIaL4Q4Q.Q Q*=yy.?@4Gyy!6!GH #*#i.A.D.D*EF#i. %:%N),A+B"EUDV WX++c1S^q5H NOM yA~Q "? yA~Q "?  $)A%5(7q=Q  => QSW.0E*,<>?  r4c\rSrSrSrg)riN__name__ __module__ __qualname____firstlineno____static_attributes__rr4r3rrr4rc\rSrSrSrg)TestirNrrr4r3rrrr4rz list[type] _DOC_ORDER__main__)N)NN)$@N)zxmas.wav)rr r)rzlist[int | float]returnzlist[int] | None)r)NTN)5__doc__ __future__r__all__rkr\rrr?unittesttypingrmusic21rrrrrrrr r!music21.audioSearchrr Environmentrrrrrr r r r r rrrrrrrrrMusic21ExceptionrTestCaserr__annotations__rmainTestrr4r3rsL # $   )+&&}5 *!Z4n.)b65,p-*`>&RN3bH  s"s  stN#b:.h  ?Pvr <88  8    J z Tr4