diff --git a/src/examples/python/example_pitch_predominantmelody.py b/src/examples/python/example_pitch_predominantmelody.py index 315f881bc..3794a724a 100644 --- a/src/examples/python/example_pitch_predominantmelody.py +++ b/src/examples/python/example_pitch_predominantmelody.py @@ -15,9 +15,8 @@ # You should have received a copy of the Affero GNU General Public License # version 3 along with this program. If not, see http://www.gnu.org/licenses/ -import sys, csv -from essentia import * -from essentia.standard import * +import sys +import essentia.standard as es from pylab import * from numpy import * @@ -26,55 +25,61 @@ try: filename = sys.argv[1] except: - print("usage: %s " % sys.argv[0]) + print(f"usage: {sys.argv[0]} ") sys.exit() - - -# We will use a composite algorithm PredominantMelody, which combines a number of -# required steps for us. Let's declare and configure it first: +# We will use a composite algorithm PredominantMelody, which combines a number of +# required steps for us. Let's declare and configure it first: hopSize = 128 frameSize = 2048 sampleRate = 44100 -guessUnvoiced = True # read the algorithm's reference for more details -run_predominant_melody = PitchMelodia(guessUnvoiced=guessUnvoiced, - frameSize=frameSize, - hopSize=hopSize); +guessUnvoiced = True # read the algorithm's reference for more details +run_predominant_melody = es.PitchMelodia( + guessUnvoiced=guessUnvoiced, frameSize=frameSize, hopSize=hopSize +) # Load audio file, apply equal loudness filter, and compute predominant melody -audio = MonoLoader(filename = filename, sampleRate=sampleRate)() -audio = EqualLoudness()(audio) +audio = es.MonoLoader(filename=filename, sampleRate=sampleRate)() +audio = es.EqualLoudness()(audio) pitch, confidence = run_predominant_melody(audio) n_frames = len(pitch) -print("number of frames: %d" % n_frames) +print(f"number of frames: {n_frames}") # Visualize output pitch values -fig = plt.figure() -plot(range(n_frames), pitch, 'b') +fig, ax = plt.subplots(1, figsize=(10, 4)) +ax.plot(range(n_frames), pitch, "b") +ax.set_xlabel("Time (s)") +ax.set_ylabel("Pitch (Hz)") +ax.set_xlim([0, n_frames - 1]) + n_ticks = 10 xtick_locs = [i * (n_frames / 10.0) for i in range(n_ticks)] -xtick_lbls = [i * (n_frames / 10.0) * hopSize / sampleRate for i in range(n_ticks)] -xtick_lbls = ["%.2f" % round(x,2) for x in xtick_lbls] +xtick_lbls = [ + i * (n_frames / 10.0) * hopSize / sampleRate for i in range(n_ticks) +] +xtick_lbls = [f"{round(x, 2):.2f}" for x in xtick_lbls] + +plt.sca(ax) plt.xticks(xtick_locs, xtick_lbls) -ax = fig.add_subplot(111) -ax.set_xlabel('Time (s)') -ax.set_ylabel('Pitch (Hz)') + suptitle("Predominant melody pitch") +tight_layout() +show() # Visualize output pitch confidence -fig = plt.figure() -plot(range(n_frames), confidence, 'b') -n_ticks = 10 -xtick_locs = [i * (n_frames / 10.0) for i in range(n_ticks)] -xtick_lbls = [i * (n_frames / 10.0) * hopSize / sampleRate for i in range(n_ticks)] -xtick_lbls = ["%.2f" % round(x,2) for x in xtick_lbls] +fig, ax = plt.subplots(1, figsize=(10, 4)) +ax.plot(range(n_frames), confidence, "b") + +ax.set_xlabel("Time (s)") +ax.set_ylabel("Confidence") +ax.set_xlim([0, n_frames - 1]) + +plt.sca(ax) plt.xticks(xtick_locs, xtick_lbls) -ax = fig.add_subplot(111) -ax.set_xlabel('Time (s)') -ax.set_ylabel('Confidence') -suptitle("Predominant melody pitch confidence") +suptitle("Predominant melody pitch confidence") +tight_layout() show() diff --git a/src/examples/python/example_pitch_predominantmelody_by_steps.py b/src/examples/python/example_pitch_predominantmelody_by_steps.py index 974482d7f..59ff52dd8 100644 --- a/src/examples/python/example_pitch_predominantmelody_by_steps.py +++ b/src/examples/python/example_pitch_predominantmelody_by_steps.py @@ -15,7 +15,7 @@ # You should have received a copy of the Affero GNU General Public License # version 3 along with this program. If not, see http://www.gnu.org/licenses/ -import sys, csv +import sys from essentia import * from essentia.standard import * from pylab import * @@ -24,36 +24,40 @@ try: filename = sys.argv[1] except: - print("usage: %s " % sys.argv[0]) + print(f"usage: {sys.argv[0]} ") sys.exit() - # In this example we will extract predominant melody given an audio file by # running a chain of algorithms. - + # First, create our algorithms: hopSize = 128 frameSize = 2048 sampleRate = 44100 guessUnvoiced = True -run_windowing = Windowing(type='hann', zeroPadding=3*frameSize) # Hann window with x4 zero padding +run_windowing = Windowing( + type="hann", zeroPadding=3 * frameSize +) # Hann window with x4 zero padding run_spectrum = Spectrum(size=frameSize * 4) -run_spectral_peaks = SpectralPeaks(minFrequency=1, - maxFrequency=20000, - maxPeaks=100, - sampleRate=sampleRate, - magnitudeThreshold=0, - orderBy="magnitude") +run_spectral_peaks = SpectralPeaks( + minFrequency=1, + maxFrequency=20000, + maxPeaks=100, + sampleRate=sampleRate, + magnitudeThreshold=0, + orderBy="magnitude", +) run_pitch_salience_function = PitchSalienceFunction() run_pitch_salience_function_peaks = PitchSalienceFunctionPeaks() run_pitch_contours = PitchContours(hopSize=hopSize) -run_pitch_contours_melody = PitchContoursMelody(guessUnvoiced=guessUnvoiced, - hopSize=hopSize) +run_pitch_contours_melody = PitchContoursMelody( + guessUnvoiced=guessUnvoiced, hopSize=hopSize +) # ... and create a Pool -pool = Pool(); +pool = Pool() # Now we are ready to start processing. # 1. Load audio and pass it through the equal-loudness filter @@ -66,54 +70,71 @@ frame = run_windowing(frame) spectrum = run_spectrum(frame) peak_frequencies, peak_magnitudes = run_spectral_peaks(spectrum) - + salience = run_pitch_salience_function(peak_frequencies, peak_magnitudes) - salience_peaks_bins, salience_peaks_saliences = run_pitch_salience_function_peaks(salience) - - pool.add('allframes_salience_peaks_bins', salience_peaks_bins) - pool.add('allframes_salience_peaks_saliences', salience_peaks_saliences) + ( + salience_peaks_bins, + salience_peaks_saliences, + ) = run_pitch_salience_function_peaks(salience) + + pool.add("allframes_salience_peaks_bins", salience_peaks_bins) + pool.add("allframes_salience_peaks_saliences", salience_peaks_saliences) -# 3. Now, as we have gathered the required per-frame data, we can feed it to the contour +# 3. Now, as we have gathered the required per-frame data, we can feed it to the contour # tracking and melody detection algorithms: -contours_bins, contours_saliences, contours_start_times, duration = run_pitch_contours( - pool['allframes_salience_peaks_bins'], - pool['allframes_salience_peaks_saliences']) -pitch, confidence = run_pitch_contours_melody(contours_bins, - contours_saliences, - contours_start_times, - duration) +( + contours_bins, + contours_saliences, + contours_start_times, + duration, +) = run_pitch_contours( + pool["allframes_salience_peaks_bins"], + pool["allframes_salience_peaks_saliences"], +) +pitch, confidence = run_pitch_contours_melody( + contours_bins, contours_saliences, contours_start_times, duration +) # NOTE that we can avoid the majority of intermediate steps by using a composite algorithm -# PredominantMelody (see extractor_predominant_melody.py). This script will be usefull +# PredominantMelody (see extractor_predominant_melody.py). This script will be usefull # if you want to get access to pitch salience function and pitch contours. n_frames = len(pitch) -print("number of frames: %d" % n_frames) +print(f"number of frames: {n_frames}") # visualize output pitch -fig = plt.figure() -plot(range(n_frames), pitch, 'b') +fig, ax = plt.subplots(1, figsize=(10, 4)) +ax.plot(range(n_frames), pitch, "b") + +ax.set_xlabel("Time (s)") +ax.set_ylabel("Pitch (Hz)") +ax.set_xlim([0, n_frames - 1]) + n_ticks = 10 xtick_locs = [i * (n_frames / 10.0) for i in range(n_ticks)] -xtick_lbls = [i * (n_frames / 10.0) * hopSize / sampleRate for i in range(n_ticks)] -xtick_lbls = ["%.2f" % round(x,2) for x in xtick_lbls] +xtick_lbls = [ + i * (n_frames / 10.0) * hopSize / sampleRate for i in range(n_ticks) +] +xtick_lbls = [f"{round(x, 2):.2f}" for x in xtick_lbls] + +plt.sca(ax) plt.xticks(xtick_locs, xtick_lbls) -ax = fig.add_subplot(111) -ax.set_xlabel('Time (s)') -ax.set_ylabel('Pitch (Hz)') + suptitle("Predominant melody pitch") +tight_layout() +show() # visualize output pitch confidence -fig = plt.figure() -plot(range(n_frames), confidence, 'b') -n_ticks = 10 -xtick_locs = [i * (n_frames / 10.0) for i in range(n_ticks)] -xtick_lbls = [i * (n_frames / 10.0) * hopSize / sampleRate for i in range(n_ticks)] -xtick_lbls = ["%.2f" % round(x,2) for x in xtick_lbls] +fig, ax = plt.subplots(1, figsize=(10, 4)) +ax.plot(range(n_frames), confidence, "b") + +ax.set_xlabel("Time (s)") +ax.set_ylabel("Confidence") +ax.set_xlim([0, n_frames - 1]) + +plt.sca(ax) plt.xticks(xtick_locs, xtick_lbls) -ax = fig.add_subplot(111) -ax.set_xlabel('Time (s)') -ax.set_ylabel('Confidence') -suptitle("Predominant melody pitch confidence") +suptitle("Predominant melody pitch confidence") +tight_layout() show() diff --git a/src/examples/python/example_rhythm_beattrackermultifeature.py b/src/examples/python/example_rhythm_beattrackermultifeature.py index e8a6973e4..099aeb0de 100644 --- a/src/examples/python/example_rhythm_beattrackermultifeature.py +++ b/src/examples/python/example_rhythm_beattrackermultifeature.py @@ -31,25 +31,25 @@ input_filename = sys.argv[1] output_filename = sys.argv[2] except: - print('usage: %s ' % sys.argv[0]) + print(f"usage: {sys.argv[0]} ") sys.exit() # don't forget, we can actually instantiate and call an algorithm on the same line! -print('Loading audio file...') -audio = MonoLoader(filename = input_filename)() +print("Loading audio file...") +audio = MonoLoader(filename=input_filename)() # compute beat positions -print('Computing beat positions...') +print("Computing beat positions...") bt = BeatTrackerMultiFeature() beats, _ = bt(audio) -print(beats) +print(f"beats: {beats}") # mark them on the audio, which we'll write back to disk # we use beeps instead of white noise to mark them, as it's more distinctive -print('Writing audio files to disk with beats marked...') +print("Writing audio files to disk with beats marked...") -marker = AudioOnsetsMarker(onsets = beats, type = 'beep') +marker = AudioOnsetsMarker(onsets=beats, type="beep") marked_audio = marker(audio) -MonoWriter(filename = output_filename)(marked_audio) +MonoWriter(filename=output_filename)(marked_audio) -print('All done!') +print("All done!") diff --git a/src/examples/python/example_rhythm_bpmhistogram.py b/src/examples/python/example_rhythm_bpmhistogram.py index 0aea1ec7b..2a732d25a 100644 --- a/src/examples/python/example_rhythm_bpmhistogram.py +++ b/src/examples/python/example_rhythm_bpmhistogram.py @@ -4,45 +4,45 @@ try: - audiofile = sys.argv[1] + audiofile = sys.argv[1] except: - print ("usage: %s " % sys.argv[0]) - sys.exit() + print(f"usage: {sys.argv[0]} ") + sys.exit() pool = essentia.Pool() -loader = MonoLoader(filename = audiofile) +loader = MonoLoader(filename=audiofile) bt = RhythmExtractor2013() bpm_histogram = BpmHistogramDescriptors() -centroid = Centroid(range=250) # BPM histogram output size is 250 +centroid = Centroid(range=250) # BPM histogram output size is 250 loader.audio >> bt.signal -bt.bpm >> (pool, 'bpm') +bt.bpm >> (pool, "bpm") bt.ticks >> None bt.confidence >> None bt.estimates >> None bt.bpmIntervals >> bpm_histogram.bpmIntervals -bpm_histogram.firstPeakBPM >> (pool, 'bpm_first_peak') +bpm_histogram.firstPeakBPM >> (pool, "bpm_first_peak") bpm_histogram.firstPeakWeight >> None bpm_histogram.firstPeakSpread >> None -bpm_histogram.secondPeakBPM >> (pool, 'bpm_second_peak') +bpm_histogram.secondPeakBPM >> (pool, "bpm_second_peak") bpm_histogram.secondPeakWeight >> None bpm_histogram.secondPeakSpread >> None -bpm_histogram.histogram >> (pool, 'bpm_histogram') +bpm_histogram.histogram >> (pool, "bpm_histogram") bpm_histogram.histogram >> centroid.array -centroid.centroid >> (pool, 'bpm_centroid') +centroid.centroid >> (pool, "bpm_centroid") essentia.run(loader) -print("BPM: %0.1f" % pool['bpm']) -print("Most prominent peak: %0.1f BPM" % pool['bpm_first_peak'][0]) -print("Centroid: %0.1f" % pool['bpm_centroid'][0]) +print(f"BPM: {pool['bpm']:.1f}") +print(f"Most prominent peak: {pool['bpm_first_peak'][0]:.1f} BPM") +print(f"Centroid: {pool['bpm_centroid'][0]:.1f}") -histogram = pool['bpm_histogram'][0] +histogram = pool["bpm_histogram"][0] fig, ax = plt.subplots() ax.bar(range(len(histogram)), histogram, width=1) -ax.set_xlabel('BPM') -ax.set_ylabel('Frequency') +ax.set_xlabel("BPM") +ax.set_ylabel("Frequency") ax.set_xticks([20 * x + 0.5 for x in range(int(len(histogram) / 20))]) ax.set_xticklabels([str(20 * x) for x in range(int(len(histogram) / 20))]) -plt.show() \ No newline at end of file +plt.show() diff --git a/src/examples/python/example_rhythm_bpmhistogramdescriptors.py b/src/examples/python/example_rhythm_bpmhistogramdescriptors.py index 29d5769aa..8c696b324 100644 --- a/src/examples/python/example_rhythm_bpmhistogramdescriptors.py +++ b/src/examples/python/example_rhythm_bpmhistogramdescriptors.py @@ -1,27 +1,34 @@ import sys from essentia.standard import * -from essentia import Pool import pylab as plt try: input_file = sys.argv[1] except: - print("usage: %s " % sys.argv[0]) + print(f"usage: {sys.argv[0]} ") sys.exit() audio = MonoLoader(filename=input_file)() bpm, _, _, _, intervals = RhythmExtractor2013()(audio) -peak1_bpm, peak1_weight, peak1_spread, peak2_bpm, peak2_weight, peak2_spread, histogram = BpmHistogramDescriptors()(intervals) +( + peak1_bpm, + peak1_weight, + peak1_spread, + peak2_bpm, + peak2_weight, + peak2_spread, + histogram, +) = BpmHistogramDescriptors()(intervals) -print("Overall BPM: %0.1f" % bpm) -print("First peak: %0.1f bpm" % peak1_bpm) -print("Second peak: %0.1f bpm" % peak2_bpm) +print(f"Overall BPM: {bpm:.1f}") +print(f"First peak: {peak1_bpm:.1f} bpm") +print(f"Second peak: {peak2_bpm:.1f} bpm") fig, ax = plt.subplots() ax.bar(range(len(histogram)), histogram, width=1) -ax.set_xlabel('BPM') -ax.set_ylabel('Frequency') +ax.set_xlabel("BPM") +ax.set_ylabel("Frequency") ax.set_xticks([20 * x + 0.5 for x in range(int(len(histogram) / 20))]) ax.set_xticklabels([str(20 * x) for x in range(int(len(histogram) / 20))]) plt.show() diff --git a/src/examples/python/example_rhythm_noveltycurve.py b/src/examples/python/example_rhythm_noveltycurve.py index c3566997b..b9a147db0 100644 --- a/src/examples/python/example_rhythm_noveltycurve.py +++ b/src/examples/python/example_rhythm_noveltycurve.py @@ -1,6 +1,6 @@ +from configparser import Interpolation import sys import essentia.standard as es -from essentia import * import numpy import pylab @@ -8,34 +8,49 @@ try: input_file = sys.argv[1] except: - print ("usage: %s " % sys.argv[0]) + print("usage: {sys.argv[0]} ") sys.exit() +sample_rate = 44100 +frame_size = 2048 +hop_size = 128 +weight = "hybrid" -frameSize = 2048 -hopSize = 128 -weight = 'hybrid' - -print("Frame size: %d" % frameSize) -print("Hop size: %d" % hopSize) -print("weight: %s" % weight) +print(f"Sample rate: {sample_rate}") +print(f"Frame size: {frame_size}") +print(f"Hop size: {hop_size}") +print(f"weight: {weight}") audio = es.MonoLoader(filename=input_file)() -w = es.Windowing(type='hann') +w = es.Windowing(type="hann") s = es.Spectrum() freq_bands = es.FrequencyBands() bands_energies = [] -for frame in es.FrameGenerator(audio, frameSize=frameSize, hopSize=hopSize): +for frame in es.FrameGenerator(audio, frameSize=frame_size, hopSize=hop_size): bands_energies.append(freq_bands(s(w(frame)))) -novelty = es.NoveltyCurve(frameRate=44100./hopSize, weightCurveType=weight)(numpy.array(bands_energies)) -bpm, candidates, magnitudes, tempogram, _, ticks, ticks_strength, sinusoid = es.BpmHistogram(frameRate=44100./hopSize)(novelty) +novelty = es.NoveltyCurve( + frameRate=sample_rate / hop_size, weightCurveType=weight +)(numpy.array(bands_energies)) +( + bpm, + candidates, + magnitudes, + tempogram, + _, + ticks, + ticks_strength, + sinusoid, +) = es.BpmHistogram(frameRate=sample_rate / hop_size)(novelty) + +print(f"BPM: {bpm:.1f}") + +pylab.plot(novelty) +pylab.suptitle("novelty") +pylab.show() -print("BPM = %0.1f" % bpm) - -#pylab.plot(novelty) -#pylab.show() -pylab.matshow(tempogram.transpose(), origin='lower', aspect='auto') +pylab.matshow(tempogram.T, origin="upper", aspect="auto", interpolation=None) +pylab.suptitle("tempogram") pylab.show() diff --git a/src/examples/python/example_rhythm_rhythmtransform.py b/src/examples/python/example_rhythm_rhythmtransform.py index 7a8f87bf8..ff3bfb574 100644 --- a/src/examples/python/example_rhythm_rhythmtransform.py +++ b/src/examples/python/example_rhythm_rhythmtransform.py @@ -5,12 +5,12 @@ try: input_file = sys.argv[1] except: - print("usage: %s " % sys.argv[0]) + print(f"usage: {sys.argv[0]} ") sys.exit() """ -Explanation of Rhythm Transform: +Explanation of Rhythm Transform: - Mel bands are computed on frames of the size 8192 with the frames sample rate = sampleRate/hopSize = 22050/1024 = 21.5Hz - Rhythm transform frame size is equal to 256 Mel bands frames - Output vector is of size 256/2 + 1 = 129. @@ -22,34 +22,40 @@ """ -sampleRate = 22050 -frameSize = 8192 -hopSize = 1024 +sampleRate = 22050 +frameSize = 8192 +hopSize = 1024 rmsFrameSize = 256 -rmsHopSize = 32 +rmsHopSize = 32 loader = MonoLoader(filename=input_file, sampleRate=sampleRate) -w = Windowing(type='blackmanharris62') +w = Windowing(type="blackmanharris62") spectrum = Spectrum() -melbands = MelBands(sampleRate=sampleRate, numberBands=40, lowFrequencyBound=0, highFrequencyBound=sampleRate/2) +melbands = MelBands( + sampleRate=sampleRate, + numberBands=40, + lowFrequencyBound=0, + highFrequencyBound=sampleRate / 2, +) pool = Pool() -for frame in FrameGenerator(audio=loader(), frameSize=frameSize, hopSize=hopSize, startFromZero=True): +for frame in FrameGenerator( + audio=loader(), frameSize=frameSize, hopSize=hopSize, startFromZero=True +): bands = melbands(spectrum(w(frame))) - pool.add('melbands', bands) + pool.add("melbands", bands) -print("Mel band frames: %d" % len(pool['melbands'])) -print("Rhythm transform frames: %d" % int(len(pool['melbands']) / 32)) +print("Mel band frames: %d" % len(pool["melbands"])) +print("Rhythm transform frames: %d" % int(len(pool["melbands"]) / 32)) rhythmtransform = RhythmTransform(frameSize=rmsFrameSize, hopSize=rmsHopSize) -rt = rhythmtransform(pool['melbands']) +rt = rhythmtransform(pool["melbands"]) import matplotlib.pyplot as plt -plt.imshow(rt.T[:,:], aspect = 'auto') -plt.xlabel('Frames') -plt.ylabel('Rhythm Transform coefficients') -plt.show() - +plt.imshow(rt.T[:, :], aspect="auto") +plt.xlabel("Frames") +plt.ylabel("Rhythm Transform coefficients") +plt.show() diff --git a/src/examples/python/tutorial_pitch_melody.ipynb b/src/examples/python/tutorial_pitch_melody.ipynb index 445775c8d..9b747501a 100644 --- a/src/examples/python/tutorial_pitch_melody.ipynb +++ b/src/examples/python/tutorial_pitch_melody.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -19,15 +19,18 @@ "\n", "# Plots\n", "import matplotlib.pyplot as plt\n", - "from pylab import plot, show, figure, imshow\n", "plt.rcParams['figure.figsize'] = (15, 6)\n", "\n", - "import numpy" + "# We'll handle with arrays\n", + "import numpy as np\n", + "\n", + "# We'll define some filepaths\n", + "from pathlib import Path" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -35,12 +38,12 @@ "output_type": "stream", "text": [ "Duration of the audio sample [sec]:\n", - "14.22859410430839\n" + "97.41061224489796\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -54,14 +57,14 @@ "source": [ "import essentia.standard as es\n", "\n", - "audiofile = '../../../test/audio/recorded/flamenco.mp3'\n", + "audiofile = Path('../../../test/audio/recorded/Vivaldi_Sonata_5_II_Allegro.wav').resolve()\n", + "sample_rate = 44100\n", "\n", "# Load audio file.\n", "# It is recommended to apply equal-loudness filter for PredominantPitchMelodia.\n", - "loader = es.EqloudLoader(filename=audiofile, sampleRate=44100)\n", - "audio = loader()\n", + "audio = es.EqloudLoader(filename=str(audiofile), sampleRate=sample_rate)()\n", "print(\"Duration of the audio sample [sec]:\")\n", - "print(len(audio)/44100.0)\n", + "print(len(audio) / sample_rate)\n", "\n", "# Extract the pitch curve\n", "# PitchMelodia takes the entire audio signal as input (no frame-wise processing is required).\n", @@ -70,13 +73,15 @@ "pitch_values, pitch_confidence = pitch_extractor(audio)\n", "\n", "# Pitch is estimated on frames. Compute frame time positions.\n", - "pitch_times = numpy.linspace(0.0,len(audio)/44100.0,len(pitch_values) )\n", + "pitch_times = np.linspace(0.0, len(audio) / sample_rate, len(pitch_values) )\n", "\n", "# Plot the estimated pitch contour and confidence over time.\n", "f, axarr = plt.subplots(2, sharex=True)\n", "axarr[0].plot(pitch_times, pitch_values)\n", + "axarr[0].set_xlim([0, pitch_times[-1]])\n", "axarr[0].set_title('estimated pitch [Hz]')\n", "axarr[1].plot(pitch_times, pitch_confidence)\n", + "axarr[1].set_xlim([0, pitch_times[-1]])\n", "axarr[1].set_title('pitch confidence')\n", "plt.show()" ] @@ -92,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -100,7 +105,7 @@ "text/html": [ "\n", " \n", " " @@ -109,7 +114,7 @@ "" ] }, - "execution_count": 3, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -120,26 +125,27 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 9, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "\n", - " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" + "ename": "Error", + "evalue": "Canceled future for execute_request message before replies were done", + "output_type": "error", + "traceback": [ + "Error: Canceled future for execute_request message before replies were done", + "at t.KernelShellFutureHandler.dispose (/Users/xavierlizarraga/.vscode/extensions/ms-toolsai.jupyter-2022.3.1000901801/out/extension.js:2:1204175)", + "at /Users/xavierlizarraga/.vscode/extensions/ms-toolsai.jupyter-2022.3.1000901801/out/extension.js:2:1223227", + "at Map.forEach ()", + "at v._clearKernelState (/Users/xavierlizarraga/.vscode/extensions/ms-toolsai.jupyter-2022.3.1000901801/out/extension.js:2:1223212)", + "at v.dispose (/Users/xavierlizarraga/.vscode/extensions/ms-toolsai.jupyter-2022.3.1000901801/out/extension.js:2:1216694)", + "at /Users/xavierlizarraga/.vscode/extensions/ms-toolsai.jupyter-2022.3.1000901801/out/extension.js:2:533674", + "at t.swallowExceptions (/Users/xavierlizarraga/.vscode/extensions/ms-toolsai.jupyter-2022.3.1000901801/out/extension.js:2:913059)", + "at dispose (/Users/xavierlizarraga/.vscode/extensions/ms-toolsai.jupyter-2022.3.1000901801/out/extension.js:2:533652)", + "at t.RawSession.dispose (/Users/xavierlizarraga/.vscode/extensions/ms-toolsai.jupyter-2022.3.1000901801/out/extension.js:2:537330)", + "at runMicrotasks ()", + "at processTicksAndRejections (node:internal/process/task_queues:96:5)" + ] } ], "source": [ @@ -147,12 +153,11 @@ "\n", "from tempfile import TemporaryDirectory\n", "temp_dir = TemporaryDirectory()\n", - "\n", + "output_filepath = Path(temp_dir.name) / 'flamenco_melody.mp3'\n", "# Essentia operates with float32 ndarrays instead of float64, so let's cast it.\n", - "synthesized_melody = pitch_contour(pitch_times, pitch_values, 44100).astype(numpy.float32)[:len(audio)]\n", - "es.AudioWriter(filename=temp_dir.name + 'flamenco_melody.mp3', format='mp3')(es.StereoMuxer()(audio, synthesized_melody))\n", - "\n", - "IPython.display.Audio(temp_dir.name + 'flamenco_melody.mp3')" + "synthesized_melody = pitch_contour(pitch_times, pitch_values, sample_rate).astype(np.float32)[:len(audio)]\n", + "es.AudioWriter(filename=str(output_filepath), format='mp3')(es.StereoMuxer()(audio, synthesized_melody))\n", + "IPython.display.Audio(str(output_filepath))" ] }, { @@ -166,42 +171,136 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "MIDI notes: [63. 64. 65. 65. 64. 63. 63. 64. 62. 60. 55. 60. 60. 61. 63. 61. 60. 59.\n", - " 61. 60. 61. 63. 61. 60. 61. 63. 61. 61. 60. 60. 60. 61. 63. 65. 65. 68.\n", - " 67. 65. 63. 55. 63. 64. 63. 65. 66. 65. 63. 62. 63. 65. 64. 61. 56.]\n", - "MIDI note onsets: [ 0.19156462 0.49052155 0.8562358 1.3960998 1.6457143 1.7502041\n", - " 1.8634014 1.9620862 2.1507483 2.2871656 3.5236282 3.822585\n", - " 4.2405443 4.4640365 4.571429 4.6701136 4.8297505 4.954558\n", - " 5.0532427 5.16644 5.265125 5.3928347 5.4915195 5.642449\n", - " 5.976236 6.135873 6.2345576 6.382585 6.4899774 6.588662\n", - " 6.7453966 6.8440814 6.986304 7.250431 7.4187756 7.5174603\n", - " 7.616145 9.00644 9.13415 10.8379135 10.942404 11.041088\n", - " 11.296508 11.395193 11.668027 11.766712 11.894422 12.036644\n", - " 12.135329 12.321089 12.419773 12.547483 14.085805 ]\n", - "MIDI note durations: [0.29315192 0.14222223 0.5340589 0.13641724 0.09868481 0.10739229\n", - " 0.09287982 0.18285714 0.13061224 1.2306576 0.29315192 0.39473924\n", - " 0.21768707 0.1015873 0.09287982 0.1538322 0.11900227 0.09287982\n", - " 0.10739229 0.09287982 0.12190476 0.09287982 0.14512472 0.14802721\n", - " 0.1538322 0.09287982 0.14222223 0.1015873 0.09287982 0.1509297\n", - " 0.09287982 0.13641724 0.258322 0.16253968 0.09287982 0.09287982\n", - " 1.3844898 0.12190476 0.14222223 0.09868481 0.09287982 0.2496145\n", - " 0.09287982 0.26702946 0.09287982 0.12190476 0.13641724 0.09287982\n", - " 0.17995465 0.09287982 0.12190476 0.11900227 0.14512472]\n" + "MIDI notes: [52. 53. 52. 52. 52. 54. 59. 60. 59. 55. 53. 52. 53. 52. 59. 55. 52. 59.\n", + " 60. 59. 57. 55. 54. 55. 52. 44. 63. 62. 52. 62. 52. 45. 60. 53. 54. 50.\n", + " 60. 62. 43. 43. 42. 51. 51. 55. 52. 55. 55. 55. 48. 53. 45. 53. 63. 52.\n", + " 55. 66. 55. 52. 51. 52. 52. 53. 52. 59. 55. 53. 52. 59. 60. 59. 55. 53.\n", + " 52. 52. 53. 52. 53. 52. 59. 60. 55. 55. 55. 53. 52. 53. 55. 57. 55. 55.\n", + " 62. 50. 62. 50. 52. 60. 55. 54. 62. 62. 59. 55. 64. 60. 57. 54. 55. 62.\n", + " 54. 55. 64. 57. 54. 55. 60. 57. 55. 62. 54. 55. 60. 62. 54. 55. 50. 55.\n", + " 55. 62. 58. 55. 62. 59. 56. 56. 62. 61. 60. 55. 54. 62. 52. 57. 60. 64.\n", + " 60. 59. 57. 52. 60. 59. 57. 52. 52. 52. 53. 52. 54. 55. 52. 52. 53. 60.\n", + " 62. 64. 62. 62. 62. 54. 52. 50. 57. 53. 52. 52. 57. 50. 52. 45. 52. 52.\n", + " 53. 52. 55. 52. 59. 60. 59. 54. 55. 52. 53. 52. 52. 59. 60. 59. 59. 55.\n", + " 54. 54. 55. 55. 52. 52. 59. 60. 53. 53. 53. 52. 57. 59. 60. 69. 60. 52.\n", + " 62. 60. 58. 64. 69. 64. 64. 63. 59. 60. 55. 56. 56. 54. 54. 55. 54. 55.\n", + " 53. 52. 52. 53. 52. 53. 52. 52. 52. 52. 55. 55. 55. 52. 54. 54. 51. 52.\n", + " 59. 44. 52. 50. 52. 62. 60. 45. 60. 54. 50. 60. 59. 59. 62. 43. 54. 59.\n", + " 57. 51. 55. 55. 52. 52. 55. 55. 53. 45. 53. 63. 66. 59. 60. 59. 55. 54.\n", + " 55. 52. 52. 52. 51. 52.]\n", + "MIDI note onsets: [ 1.039093 1.3757824 1.4744672 1.5905669 1.9765986 2.1362357\n", + " 2.2349207 2.5106575 2.777687 3.0389116 3.2595012 3.363991\n", + " 3.616508 3.7180953 3.8603175 4.040272 4.226032 4.504671\n", + " 4.754286 5.07356 5.17805 5.3057594 5.526349 5.630839\n", + " 5.8456235 6.7512016 7.0414515 7.1401362 7.404263 7.69161\n", + " 7.9992743 8.568163 8.846803 9.154468 9.258957 9.740771\n", + " 10.068753 10.620227 10.898867 11.354558 11.459047 12.033742\n", + " 12.2049885 12.582313 13.186031 13.470476 13.667846 13.798458\n", + " 14.053878 14.164172 14.457324 14.666304 15.020409 15.293242\n", + " 16.439728 16.840273 17.203083 17.47882 18.05932 18.40762\n", + " 19.789206 20.093967 20.233288 20.352291 20.517733 20.726711\n", + " 20.834105 20.993742 21.266577 21.513288 21.745487 22.015419\n", + " 22.114105 22.302767 22.401451 22.500135 22.903584 23.010975\n", + " 23.20254 23.495691 24.02975 24.148752 24.247438 24.650885\n", + " 24.755375 25.138504 25.237188 25.527437 26.772608 26.88\n", + " 27.266031 28.325441 29.39356 30.804173 31.047981 31.387573\n", + " 32.00871 32.240906 32.50794 33.076824 33.19873 33.37288\n", + " 33.75601 34.22041 34.545486 34.832836 35.384308 35.66295\n", + " 35.985126 36.52499 36.832653 37.064854 37.163536 37.697598\n", + " 38.08653 38.881813 39.00372 39.137234 39.427483 39.709026\n", + " 40.010883 41.116734 41.34603 41.45923 42.466396 42.861134\n", + " 43.107845 43.398094 43.575146 43.769615 43.943764 44.19338\n", + " 44.297867 44.396553 44.49524 44.67229 44.770973 44.889977\n", + " 45.09315 45.374695 45.908752 46.257053 46.38186 46.805622\n", + " 46.924625 47.075554 47.17424 47.32227 48.03628 48.204624\n", + " 48.30331 48.4107 48.70095 48.927345 49.542675 49.713924\n", + " 49.818413 50.146393 50.262493 50.427937 50.683357 50.924263\n", + " 51.21161 51.79211 52.16653 52.407436 52.509026 52.776054\n", + " 52.961815 53.336235 53.440727 53.913834 54.044445 54.253426\n", + " 54.42177 54.665577 55.034195 55.518913 57.118187 57.338776\n", + " 57.515827 57.614513 57.884445 58.023766 58.325623 58.65941\n", + " 58.990295 59.178955 59.283447 59.533062 59.826214 59.9278\n", + " 60.374786 60.560543 60.894333 61.21941 61.341316 61.46612\n", + " 61.61415 61.715736 61.814423 61.979862 62.10467 62.307846\n", + " 62.659046 62.79256 63.303402 63.47755 63.576237 64.36281\n", + " 65.007164 65.11166 65.23356 65.34386 65.50059 65.61959\n", + " 65.7473 65.92725 66.12173 67.65714 67.98512 68.089615\n", + " 68.21152 68.324715 68.4234 68.52209 69.76726 69.99946\n", + " 70.71056 70.878914 71.12272 71.28816 71.45071 71.70032\n", + " 71.813515 72.00798 72.185036 72.28372 72.513016 72.79746\n", + " 73.137054 73.25315 73.67111 73.807526 73.932335 75.070114\n", + " 75.27619 75.673836 75.990204 76.17306 76.30367 76.657776\n", + " 77.7375 78.13805 78.45152 78.55601 78.898506 79.20907\n", + " 79.4819 80.103035 80.4078 80.70386 81.30757 81.62975\n", + " 81.90259 82.09995 82.19864 82.454056 83.028755 83.3161\n", + " 83.47864 83.667305 84.25941 84.465485 84.83991 85.02857\n", + " 85.17079 85.2927 85.88771 86.15184 86.442085 86.79619\n", + " 86.921 87.90204 88.11973 88.3171 88.81633 88.920815\n", + " 89.106575 89.40553 89.78576 90.105034 90.209526 90.897415 ]\n", + "MIDI note durations: [0.33088437 0.09287982 0.11029478 0.17414966 0.1538322 0.09287982\n", + " 0.26993197 0.26122448 0.16544218 0.16253968 0.09868481 0.24671201\n", + " 0.09578231 0.13641724 0.14802721 0.17995465 0.23510204 0.24380952\n", + " 0.29024944 0.09868481 0.12190476 0.21478458 0.09868481 0.09868481\n", + " 0.73142856 0.28444445 0.09287982 0.258322 0.28154194 0.28154194\n", + " 0.5630839 0.27283448 0.29605442 0.09868481 0.14222223 0.32217687\n", + " 0.264127 0.12190476 0.29024944 0.09868481 0.18575963 0.16544218\n", + " 0.11609977 0.26993197 0.27863947 0.17414966 0.12480725 0.13061224\n", + " 0.1015873 0.28734693 0.2031746 0.34829932 0.10739229 0.11609977\n", + " 0.15673469 0.18575963 0.26993197 0.3599093 0.26122448 1.004263\n", + " 0.16544218 0.13351473 0.11319728 0.1044898 0.2031746 0.1015873\n", + " 0.09287982 0.26702946 0.24090703 0.12770975 0.264127 0.09287982\n", + " 0.18285714 0.09287982 0.09287982 0.39764172 0.1015873 0.18575963\n", + " 0.28734693 0.26993197 0.11319728 0.09287982 0.13931973 0.09868481\n", + " 0.37732425 0.09287982 0.24090703 0.1509297 0.1015873 0.3628118\n", + " 0.32217687 0.1015873 0.32798186 0.23800454 0.33378685 0.6153288\n", + " 0.22639456 0.2554195 0.5630839 0.11609977 0.16834468 0.37732425\n", + " 0.4585941 0.31927437 0.17414966 0.54566896 0.27283448 0.3163719\n", + " 0.5340589 0.3018594 0.22639456 0.09287982 0.528254 0.38312924\n", + " 0.28444445 0.11609977 0.12770975 0.28444445 0.27573696 0.29605442\n", + " 0.34539682 0.22349206 0.10739229 0.28734693 0.38893425 0.21768707\n", + " 0.28444445 0.17124717 0.17124717 0.16834468 0.09287982 0.09868481\n", + " 0.09287982 0.09287982 0.17124717 0.09287982 0.11319728 0.19736962\n", + " 0.27573696 0.1015873 0.34249434 0.11900227 0.09578231 0.11319728\n", + " 0.14512472 0.09287982 0.14222223 0.510839 0.16253968 0.09287982\n", + " 0.09578231 0.28444445 0.22058956 0.60952383 0.12190476 0.09868481\n", + " 0.32217687 0.11029478 0.15963718 0.2496145 0.12190476 0.28154194\n", + " 0.5485714 0.3686168 0.23510204 0.09578231 0.14512472 0.15963718\n", + " 0.3105669 0.09868481 0.16834468 0.12480725 0.2031746 0.16253968\n", + " 0.11609977 0.3628118 0.47891158 0.9723356 0.21478458 0.17124717\n", + " 0.09287982 0.252517 0.13351473 0.24380952 0.32798186 0.32507935\n", + " 0.13641724 0.09868481 0.21768707 0.28734693 0.09578231 0.3105669\n", + " 0.17995465 0.32798186 0.31927437 0.11609977 0.11900227 0.14222223\n", + " 0.09578231 0.09287982 0.13061224 0.1044898 0.19736962 0.34539682\n", + " 0.12770975 0.12480725 0.16834468 0.09287982 0.7198186 0.13931973\n", + " 0.09868481 0.11609977 0.1044898 0.09287982 0.10739229 0.12190476\n", + " 0.1538322 0.18866213 0.17414966 0.27573696 0.09868481 0.11609977\n", + " 0.10739229 0.09287982 0.09287982 0.09287982 0.22639456 0.27573696\n", + " 0.15673469 0.23800454 0.15963718 0.15673469 0.24380952 0.10739229\n", + " 0.17705216 0.17124717 0.09287982 0.21478458 0.20897959 0.23219955\n", + " 0.11029478 0.4121542 0.13061224 0.1044898 0.21478458 0.20027211\n", + " 0.39183673 0.29895693 0.17705216 0.09578231 0.26702946 0.9258957\n", + " 0.22929706 0.28734693 0.09868481 0.31346938 0.30476192 0.264127\n", + " 0.32798186 0.29895693 0.29024944 0.31927437 0.3163719 0.26702946\n", + " 0.19156462 0.09287982 0.17705216 0.32507935 0.28154194 0.15673469\n", + " 0.13351473 0.24380952 0.20027211 0.3570068 0.18285714 0.13641724\n", + " 0.11609977 0.31927437 0.2496145 0.26993197 0.34829932 0.11900227\n", + " 0.20027211 0.21188208 0.19156462 0.33378685 0.09868481 0.17995465\n", + " 0.29315192 0.37151927 0.11900227 0.09868481 0.5688889 3.3959184 ]\n" ] } ], "source": [ "onsets, durations, notes = es.PitchContourSegmentation(hopSize=128)(pitch_values, audio)\n", - "print(\"MIDI notes:\", notes) # Midi pitch number\n", - "print(\"MIDI note onsets:\", onsets)\n", - "print(\"MIDI note durations:\", durations)" + "print(f\"MIDI notes: {notes}\") # Midi pitch number\n", + "print(f\"MIDI note onsets: {onsets}\")\n", + "print(f\"MIDI note durations: {durations}\")" ] }, { @@ -213,14 +312,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "MIDI file location: /tmp/tmpf6zzwakg/extracted_melody.mid\n" + "MIDI file location: /var/folders/3g/q4r28x096njgm19kspzz3qvr0000gn/T/tmpionbog5d/extracted_melody.mid\n" ] } ], @@ -241,14 +340,14 @@ "mid.tracks.append(track)\n", "\n", "for note, onset, duration, silence_duration in zip(list(notes), list(onsets), list(durations), silence_durations):\n", - " track.append(mido.Message('note_on', note=int(note), velocity=64, \n", + " track.append(mido.Message('note_on', note=int(note), velocity=64,\n", " time=int(mido.second2tick(duration, PPQ, tempo))))\n", - " track.append(mido.Message('note_off', note=int(note), \n", + " track.append(mido.Message('note_off', note=int(note),\n", " time=int(mido.second2tick(silence_duration, PPQ, tempo))))\n", "\n", - "midi_file = temp_dir.name + '/extracted_melody.mid'\n", + "midi_file = Path(temp_dir.name) / 'extracted_melody.mid'\n", "mid.save(midi_file)\n", - "print(\"MIDI file location:\", midi_file)" + "print(f\"MIDI file location: {midi_file}\")" ] } ], @@ -268,7 +367,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.9.5" } }, "nbformat": 4, diff --git a/src/examples/python/tutorial_tensorflow_real-time_auto-tagging.ipynb b/src/examples/python/tutorial_tensorflow_real-time_auto-tagging.ipynb index bdbf9ddd4..8dfbbff6c 100644 --- a/src/examples/python/tutorial_tensorflow_real-time_auto-tagging.ipynb +++ b/src/examples/python/tutorial_tensorflow_real-time_auto-tagging.ipynb @@ -215,939 +215,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - " if (this.ratio !== 1) {\n", - " fig.send_message('set_dpi_ratio', { dpi_ratio: this.ratio });\n", - " }\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " var resizeObserver = new ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " resizeObserver.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch (cursor) {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = 'image/png';\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.which === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.which;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which !== 17) {\n", - " value += 'ctrl+';\n", - " }\n", - " if (event.altKey && event.which !== 18) {\n", - " value += 'alt+';\n", - " }\n", - " if (event.shiftKey && event.which !== 16) {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data']);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.one(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager) {\n", - " manager = IPython.keyboard_manager;\n", - " }\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], + "application/javascript": "/* Put everything inside the global mpl namespace */\n/* global mpl */\nwindow.mpl = {};\n\nmpl.get_websocket_type = function () {\n if (typeof WebSocket !== 'undefined') {\n return WebSocket;\n } else if (typeof MozWebSocket !== 'undefined') {\n return MozWebSocket;\n } else {\n alert(\n 'Your browser does not have WebSocket support. ' +\n 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n 'Firefox 4 and 5 are also supported but you ' +\n 'have to enable WebSockets in about:config.'\n );\n }\n};\n\nmpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n this.id = figure_id;\n\n this.ws = websocket;\n\n this.supports_binary = this.ws.binaryType !== undefined;\n\n if (!this.supports_binary) {\n var warnings = document.getElementById('mpl-warnings');\n if (warnings) {\n warnings.style.display = 'block';\n warnings.textContent =\n 'This browser does not support binary websocket messages. ' +\n 'Performance may be slow.';\n }\n }\n\n this.imageObj = new Image();\n\n this.context = undefined;\n this.message = undefined;\n this.canvas = undefined;\n this.rubberband_canvas = undefined;\n this.rubberband_context = undefined;\n this.format_dropdown = undefined;\n\n this.image_mode = 'full';\n\n this.root = document.createElement('div');\n this.root.setAttribute('style', 'display: inline-block');\n this._root_extra_style(this.root);\n\n parent_element.appendChild(this.root);\n\n this._init_header(this);\n this._init_canvas(this);\n this._init_toolbar(this);\n\n var fig = this;\n\n this.waiting = false;\n\n this.ws.onopen = function () {\n fig.send_message('supports_binary', { value: fig.supports_binary });\n fig.send_message('send_image_mode', {});\n if (fig.ratio !== 1) {\n fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n }\n fig.send_message('refresh', {});\n };\n\n this.imageObj.onload = function () {\n if (fig.image_mode === 'full') {\n // Full images could contain transparency (where diff images\n // almost always do), so we need to clear the canvas so that\n // there is no ghosting.\n fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n }\n fig.context.drawImage(fig.imageObj, 0, 0);\n };\n\n this.imageObj.onunload = function () {\n fig.ws.close();\n };\n\n this.ws.onmessage = this._make_on_message_function(this);\n\n this.ondownload = ondownload;\n};\n\nmpl.figure.prototype._init_header = function () {\n var titlebar = document.createElement('div');\n titlebar.classList =\n 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n var titletext = document.createElement('div');\n titletext.classList = 'ui-dialog-title';\n titletext.setAttribute(\n 'style',\n 'width: 100%; text-align: center; padding: 3px;'\n );\n titlebar.appendChild(titletext);\n this.root.appendChild(titlebar);\n this.header = titletext;\n};\n\nmpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._init_canvas = function () {\n var fig = this;\n\n var canvas_div = (this.canvas_div = document.createElement('div'));\n canvas_div.setAttribute(\n 'style',\n 'border: 1px solid #ddd;' +\n 'box-sizing: content-box;' +\n 'clear: both;' +\n 'min-height: 1px;' +\n 'min-width: 1px;' +\n 'outline: 0;' +\n 'overflow: hidden;' +\n 'position: relative;' +\n 'resize: both;'\n );\n\n function on_keyboard_event_closure(name) {\n return function (event) {\n return fig.key_event(event, name);\n };\n }\n\n canvas_div.addEventListener(\n 'keydown',\n on_keyboard_event_closure('key_press')\n );\n canvas_div.addEventListener(\n 'keyup',\n on_keyboard_event_closure('key_release')\n );\n\n this._canvas_extra_style(canvas_div);\n this.root.appendChild(canvas_div);\n\n var canvas = (this.canvas = document.createElement('canvas'));\n canvas.classList.add('mpl-canvas');\n canvas.setAttribute('style', 'box-sizing: content-box;');\n\n this.context = canvas.getContext('2d');\n\n var backingStore =\n this.context.backingStorePixelRatio ||\n this.context.webkitBackingStorePixelRatio ||\n this.context.mozBackingStorePixelRatio ||\n this.context.msBackingStorePixelRatio ||\n this.context.oBackingStorePixelRatio ||\n this.context.backingStorePixelRatio ||\n 1;\n\n this.ratio = (window.devicePixelRatio || 1) / backingStore;\n if (this.ratio !== 1) {\n fig.send_message('set_dpi_ratio', { dpi_ratio: this.ratio });\n }\n\n var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n 'canvas'\n ));\n rubberband_canvas.setAttribute(\n 'style',\n 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n );\n\n var resizeObserver = new ResizeObserver(function (entries) {\n var nentries = entries.length;\n for (var i = 0; i < nentries; i++) {\n var entry = entries[i];\n var width, height;\n if (entry.contentBoxSize) {\n if (entry.contentBoxSize instanceof Array) {\n // Chrome 84 implements new version of spec.\n width = entry.contentBoxSize[0].inlineSize;\n height = entry.contentBoxSize[0].blockSize;\n } else {\n // Firefox implements old version of spec.\n width = entry.contentBoxSize.inlineSize;\n height = entry.contentBoxSize.blockSize;\n }\n } else {\n // Chrome <84 implements even older version of spec.\n width = entry.contentRect.width;\n height = entry.contentRect.height;\n }\n\n // Keep the size of the canvas and rubber band canvas in sync with\n // the canvas container.\n if (entry.devicePixelContentBoxSize) {\n // Chrome 84 implements new version of spec.\n canvas.setAttribute(\n 'width',\n entry.devicePixelContentBoxSize[0].inlineSize\n );\n canvas.setAttribute(\n 'height',\n entry.devicePixelContentBoxSize[0].blockSize\n );\n } else {\n canvas.setAttribute('width', width * fig.ratio);\n canvas.setAttribute('height', height * fig.ratio);\n }\n canvas.setAttribute(\n 'style',\n 'width: ' + width + 'px; height: ' + height + 'px;'\n );\n\n rubberband_canvas.setAttribute('width', width);\n rubberband_canvas.setAttribute('height', height);\n\n // And update the size in Python. We ignore the initial 0/0 size\n // that occurs as the element is placed into the DOM, which should\n // otherwise not happen due to the minimum size styling.\n if (width != 0 && height != 0) {\n fig.request_resize(width, height);\n }\n }\n });\n resizeObserver.observe(canvas_div);\n\n function on_mouse_event_closure(name) {\n return function (event) {\n return fig.mouse_event(event, name);\n };\n }\n\n rubberband_canvas.addEventListener(\n 'mousedown',\n on_mouse_event_closure('button_press')\n );\n rubberband_canvas.addEventListener(\n 'mouseup',\n on_mouse_event_closure('button_release')\n );\n // Throttle sequential mouse events to 1 every 20ms.\n rubberband_canvas.addEventListener(\n 'mousemove',\n on_mouse_event_closure('motion_notify')\n );\n\n rubberband_canvas.addEventListener(\n 'mouseenter',\n on_mouse_event_closure('figure_enter')\n );\n rubberband_canvas.addEventListener(\n 'mouseleave',\n on_mouse_event_closure('figure_leave')\n );\n\n canvas_div.addEventListener('wheel', function (event) {\n if (event.deltaY < 0) {\n event.step = 1;\n } else {\n event.step = -1;\n }\n on_mouse_event_closure('scroll')(event);\n });\n\n canvas_div.appendChild(canvas);\n canvas_div.appendChild(rubberband_canvas);\n\n this.rubberband_context = rubberband_canvas.getContext('2d');\n this.rubberband_context.strokeStyle = '#000000';\n\n this._resize_canvas = function (width, height, forward) {\n if (forward) {\n canvas_div.style.width = width + 'px';\n canvas_div.style.height = height + 'px';\n }\n };\n\n // Disable right mouse context menu.\n this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n event.preventDefault();\n return false;\n });\n\n function set_focus() {\n canvas.focus();\n canvas_div.focus();\n }\n\n window.setTimeout(set_focus, 100);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n var fig = this;\n\n var toolbar = document.createElement('div');\n toolbar.classList = 'mpl-toolbar';\n this.root.appendChild(toolbar);\n\n function on_click_closure(name) {\n return function (_event) {\n return fig.toolbar_button_onclick(name);\n };\n }\n\n function on_mouseover_closure(tooltip) {\n return function (event) {\n if (!event.currentTarget.disabled) {\n return fig.toolbar_button_onmouseover(tooltip);\n }\n };\n }\n\n fig.buttons = {};\n var buttonGroup = document.createElement('div');\n buttonGroup.classList = 'mpl-button-group';\n for (var toolbar_ind in mpl.toolbar_items) {\n var name = mpl.toolbar_items[toolbar_ind][0];\n var tooltip = mpl.toolbar_items[toolbar_ind][1];\n var image = mpl.toolbar_items[toolbar_ind][2];\n var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n if (!name) {\n /* Instead of a spacer, we start a new button group. */\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n buttonGroup = document.createElement('div');\n buttonGroup.classList = 'mpl-button-group';\n continue;\n }\n\n var button = (fig.buttons[name] = document.createElement('button'));\n button.classList = 'mpl-widget';\n button.setAttribute('role', 'button');\n button.setAttribute('aria-disabled', 'false');\n button.addEventListener('click', on_click_closure(method_name));\n button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n\n var icon_img = document.createElement('img');\n icon_img.src = '_images/' + image + '.png';\n icon_img.srcset = '_images/' + image + '_large.png 2x';\n icon_img.alt = tooltip;\n button.appendChild(icon_img);\n\n buttonGroup.appendChild(button);\n }\n\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n\n var fmt_picker = document.createElement('select');\n fmt_picker.classList = 'mpl-widget';\n toolbar.appendChild(fmt_picker);\n this.format_dropdown = fmt_picker;\n\n for (var ind in mpl.extensions) {\n var fmt = mpl.extensions[ind];\n var option = document.createElement('option');\n option.selected = fmt === mpl.default_extension;\n option.innerHTML = fmt;\n fmt_picker.appendChild(option);\n }\n\n var status_bar = document.createElement('span');\n status_bar.classList = 'mpl-message';\n toolbar.appendChild(status_bar);\n this.message = status_bar;\n};\n\nmpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n // which will in turn request a refresh of the image.\n this.send_message('resize', { width: x_pixels, height: y_pixels });\n};\n\nmpl.figure.prototype.send_message = function (type, properties) {\n properties['type'] = type;\n properties['figure_id'] = this.id;\n this.ws.send(JSON.stringify(properties));\n};\n\nmpl.figure.prototype.send_draw_message = function () {\n if (!this.waiting) {\n this.waiting = true;\n this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n var format_dropdown = fig.format_dropdown;\n var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n fig.ondownload(fig, format);\n};\n\nmpl.figure.prototype.handle_resize = function (fig, msg) {\n var size = msg['size'];\n if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n fig._resize_canvas(size[0], size[1], msg['forward']);\n fig.send_message('refresh', {});\n }\n};\n\nmpl.figure.prototype.handle_rubberband = function (fig, msg) {\n var x0 = msg['x0'] / fig.ratio;\n var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n var x1 = msg['x1'] / fig.ratio;\n var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n x0 = Math.floor(x0) + 0.5;\n y0 = Math.floor(y0) + 0.5;\n x1 = Math.floor(x1) + 0.5;\n y1 = Math.floor(y1) + 0.5;\n var min_x = Math.min(x0, x1);\n var min_y = Math.min(y0, y1);\n var width = Math.abs(x1 - x0);\n var height = Math.abs(y1 - y0);\n\n fig.rubberband_context.clearRect(\n 0,\n 0,\n fig.canvas.width / fig.ratio,\n fig.canvas.height / fig.ratio\n );\n\n fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n};\n\nmpl.figure.prototype.handle_figure_label = function (fig, msg) {\n // Updates the figure title.\n fig.header.textContent = msg['label'];\n};\n\nmpl.figure.prototype.handle_cursor = function (fig, msg) {\n var cursor = msg['cursor'];\n switch (cursor) {\n case 0:\n cursor = 'pointer';\n break;\n case 1:\n cursor = 'default';\n break;\n case 2:\n cursor = 'crosshair';\n break;\n case 3:\n cursor = 'move';\n break;\n }\n fig.rubberband_canvas.style.cursor = cursor;\n};\n\nmpl.figure.prototype.handle_message = function (fig, msg) {\n fig.message.textContent = msg['message'];\n};\n\nmpl.figure.prototype.handle_draw = function (fig, _msg) {\n // Request the server to send over a new figure.\n fig.send_draw_message();\n};\n\nmpl.figure.prototype.handle_image_mode = function (fig, msg) {\n fig.image_mode = msg['mode'];\n};\n\nmpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n for (var key in msg) {\n if (!(key in fig.buttons)) {\n continue;\n }\n fig.buttons[key].disabled = !msg[key];\n fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n }\n};\n\nmpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n if (msg['mode'] === 'PAN') {\n fig.buttons['Pan'].classList.add('active');\n fig.buttons['Zoom'].classList.remove('active');\n } else if (msg['mode'] === 'ZOOM') {\n fig.buttons['Pan'].classList.remove('active');\n fig.buttons['Zoom'].classList.add('active');\n } else {\n fig.buttons['Pan'].classList.remove('active');\n fig.buttons['Zoom'].classList.remove('active');\n }\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n // Called whenever the canvas gets updated.\n this.send_message('ack', {});\n};\n\n// A function to construct a web socket function for onmessage handling.\n// Called in the figure constructor.\nmpl.figure.prototype._make_on_message_function = function (fig) {\n return function socket_on_message(evt) {\n if (evt.data instanceof Blob) {\n /* FIXME: We get \"Resource interpreted as Image but\n * transferred with MIME type text/plain:\" errors on\n * Chrome. But how to set the MIME type? It doesn't seem\n * to be part of the websocket stream */\n evt.data.type = 'image/png';\n\n /* Free the memory for the previous frames */\n if (fig.imageObj.src) {\n (window.URL || window.webkitURL).revokeObjectURL(\n fig.imageObj.src\n );\n }\n\n fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n evt.data\n );\n fig.updated_canvas_event();\n fig.waiting = false;\n return;\n } else if (\n typeof evt.data === 'string' &&\n evt.data.slice(0, 21) === 'data:image/png;base64'\n ) {\n fig.imageObj.src = evt.data;\n fig.updated_canvas_event();\n fig.waiting = false;\n return;\n }\n\n var msg = JSON.parse(evt.data);\n var msg_type = msg['type'];\n\n // Call the \"handle_{type}\" callback, which takes\n // the figure and JSON message as its only arguments.\n try {\n var callback = fig['handle_' + msg_type];\n } catch (e) {\n console.log(\n \"No handler for the '\" + msg_type + \"' message type: \",\n msg\n );\n return;\n }\n\n if (callback) {\n try {\n // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n callback(fig, msg);\n } catch (e) {\n console.log(\n \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n e,\n e.stack,\n msg\n );\n }\n }\n };\n};\n\n// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\nmpl.findpos = function (e) {\n //this section is from http://www.quirksmode.org/js/events_properties.html\n var targ;\n if (!e) {\n e = window.event;\n }\n if (e.target) {\n targ = e.target;\n } else if (e.srcElement) {\n targ = e.srcElement;\n }\n if (targ.nodeType === 3) {\n // defeat Safari bug\n targ = targ.parentNode;\n }\n\n // pageX,Y are the mouse positions relative to the document\n var boundingRect = targ.getBoundingClientRect();\n var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n\n return { x: x, y: y };\n};\n\n/*\n * return a copy of an object with only non-object keys\n * we need this to avoid circular references\n * http://stackoverflow.com/a/24161582/3208463\n */\nfunction simpleKeys(original) {\n return Object.keys(original).reduce(function (obj, key) {\n if (typeof original[key] !== 'object') {\n obj[key] = original[key];\n }\n return obj;\n }, {});\n}\n\nmpl.figure.prototype.mouse_event = function (event, name) {\n var canvas_pos = mpl.findpos(event);\n\n if (name === 'button_press') {\n this.canvas.focus();\n this.canvas_div.focus();\n }\n\n var x = canvas_pos.x * this.ratio;\n var y = canvas_pos.y * this.ratio;\n\n this.send_message(name, {\n x: x,\n y: y,\n button: event.button,\n step: event.step,\n guiEvent: simpleKeys(event),\n });\n\n /* This prevents the web browser from automatically changing to\n * the text insertion cursor when the button is pressed. We want\n * to control all of the cursor setting manually through the\n * 'cursor' event from matplotlib */\n event.preventDefault();\n return false;\n};\n\nmpl.figure.prototype._key_event_extra = function (_event, _name) {\n // Handle any extra behaviour associated with a key event\n};\n\nmpl.figure.prototype.key_event = function (event, name) {\n // Prevent repeat events\n if (name === 'key_press') {\n if (event.which === this._key) {\n return;\n } else {\n this._key = event.which;\n }\n }\n if (name === 'key_release') {\n this._key = null;\n }\n\n var value = '';\n if (event.ctrlKey && event.which !== 17) {\n value += 'ctrl+';\n }\n if (event.altKey && event.which !== 18) {\n value += 'alt+';\n }\n if (event.shiftKey && event.which !== 16) {\n value += 'shift+';\n }\n\n value += 'k';\n value += event.which.toString();\n\n this._key_event_extra(event, name);\n\n this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n return false;\n};\n\nmpl.figure.prototype.toolbar_button_onclick = function (name) {\n if (name === 'download') {\n this.handle_save(this, null);\n } else {\n this.send_message('toolbar_button', { name: name });\n }\n};\n\nmpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n this.message.textContent = tooltip;\n};\nmpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n\nmpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n\nmpl.default_extension = \"png\";/* global mpl */\n\nvar comm_websocket_adapter = function (comm) {\n // Create a \"websocket\"-like object which calls the given IPython comm\n // object with the appropriate methods. Currently this is a non binary\n // socket, so there is still some room for performance tuning.\n var ws = {};\n\n ws.close = function () {\n comm.close();\n };\n ws.send = function (m) {\n //console.log('sending', m);\n comm.send(m);\n };\n // Register the callback with on_msg.\n comm.on_msg(function (msg) {\n //console.log('receiving', msg['content']['data'], msg);\n // Pass the mpl event to the overridden (by mpl) onmessage function.\n ws.onmessage(msg['content']['data']);\n });\n return ws;\n};\n\nmpl.mpl_figure_comm = function (comm, msg) {\n // This is the function which gets called when the mpl process\n // starts-up an IPython Comm through the \"matplotlib\" channel.\n\n var id = msg.content.data.id;\n // Get hold of the div created by the display call when the Comm\n // socket was opened in Python.\n var element = document.getElementById(id);\n var ws_proxy = comm_websocket_adapter(comm);\n\n function ondownload(figure, _format) {\n window.open(figure.canvas.toDataURL());\n }\n\n var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n\n // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n // web socket which is closed, not our websocket->open comm proxy.\n ws_proxy.onopen();\n\n fig.parent_element = element;\n fig.cell_info = mpl.find_output_cell(\"
\");\n if (!fig.cell_info) {\n console.error('Failed to find cell for figure', id, fig);\n return;\n }\n fig.cell_info[0].output_area.element.one(\n 'cleared',\n { fig: fig },\n fig._remove_fig_handler\n );\n};\n\nmpl.figure.prototype.handle_close = function (fig, msg) {\n var width = fig.canvas.width / fig.ratio;\n fig.cell_info[0].output_area.element.off(\n 'cleared',\n fig._remove_fig_handler\n );\n\n // Update the output cell to use the data from the current canvas.\n fig.push_to_output();\n var dataURL = fig.canvas.toDataURL();\n // Re-enable the keyboard manager in IPython - without this line, in FF,\n // the notebook keyboard shortcuts fail.\n IPython.keyboard_manager.enable();\n fig.parent_element.innerHTML =\n '';\n fig.close_ws(fig, msg);\n};\n\nmpl.figure.prototype.close_ws = function (fig, msg) {\n fig.send_message('closing', msg);\n // fig.ws.close()\n};\n\nmpl.figure.prototype.push_to_output = function (_remove_interactive) {\n // Turn the data on the canvas into data in the output cell.\n var width = this.canvas.width / this.ratio;\n var dataURL = this.canvas.toDataURL();\n this.cell_info[1]['text/html'] =\n '';\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n // Tell IPython that the notebook contents must change.\n IPython.notebook.set_dirty(true);\n this.send_message('ack', {});\n var fig = this;\n // Wait a second, then push the new image to the DOM so\n // that it is saved nicely (might be nice to debounce this).\n setTimeout(function () {\n fig.push_to_output();\n }, 1000);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n var fig = this;\n\n var toolbar = document.createElement('div');\n toolbar.classList = 'btn-toolbar';\n this.root.appendChild(toolbar);\n\n function on_click_closure(name) {\n return function (_event) {\n return fig.toolbar_button_onclick(name);\n };\n }\n\n function on_mouseover_closure(tooltip) {\n return function (event) {\n if (!event.currentTarget.disabled) {\n return fig.toolbar_button_onmouseover(tooltip);\n }\n };\n }\n\n fig.buttons = {};\n var buttonGroup = document.createElement('div');\n buttonGroup.classList = 'btn-group';\n var button;\n for (var toolbar_ind in mpl.toolbar_items) {\n var name = mpl.toolbar_items[toolbar_ind][0];\n var tooltip = mpl.toolbar_items[toolbar_ind][1];\n var image = mpl.toolbar_items[toolbar_ind][2];\n var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n if (!name) {\n /* Instead of a spacer, we start a new button group. */\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n buttonGroup = document.createElement('div');\n buttonGroup.classList = 'btn-group';\n continue;\n }\n\n button = fig.buttons[name] = document.createElement('button');\n button.classList = 'btn btn-default';\n button.href = '#';\n button.title = name;\n button.innerHTML = '';\n button.addEventListener('click', on_click_closure(method_name));\n button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n buttonGroup.appendChild(button);\n }\n\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n\n // Add the status bar.\n var status_bar = document.createElement('span');\n status_bar.classList = 'mpl-message pull-right';\n toolbar.appendChild(status_bar);\n this.message = status_bar;\n\n // Add the close button to the window.\n var buttongrp = document.createElement('div');\n buttongrp.classList = 'btn-group inline pull-right';\n button = document.createElement('button');\n button.classList = 'btn btn-mini btn-primary';\n button.href = '#';\n button.title = 'Stop Interaction';\n button.innerHTML = '';\n button.addEventListener('click', function (_evt) {\n fig.handle_close(fig, {});\n });\n button.addEventListener(\n 'mouseover',\n on_mouseover_closure('Stop Interaction')\n );\n buttongrp.appendChild(button);\n var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n titlebar.insertBefore(buttongrp, titlebar.firstChild);\n};\n\nmpl.figure.prototype._remove_fig_handler = function (event) {\n var fig = event.data.fig;\n fig.close_ws(fig, {});\n};\n\nmpl.figure.prototype._root_extra_style = function (el) {\n el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n};\n\nmpl.figure.prototype._canvas_extra_style = function (el) {\n // this is important to make the div 'focusable\n el.setAttribute('tabindex', 0);\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n } else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n};\n\nmpl.figure.prototype._key_event_extra = function (event, _name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager) {\n manager = IPython.keyboard_manager;\n }\n\n // Check for shift+enter\n if (event.shiftKey && event.which === 13) {\n this.canvas_div.blur();\n // select the cell after this one\n var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n IPython.notebook.select(index + 1);\n }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n fig.ondownload(fig, null);\n};\n\nmpl.find_output_cell = function (html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i = 0; i < ncells; i++) {\n var cell = cells[i];\n if (cell.cell_type === 'code') {\n for (var j = 0; j < cell.output_area.outputs.length; j++) {\n var data = cell.output_area.outputs[j];\n if (data.data) {\n // IPython >= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] === html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n};\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel !== null) {\n IPython.notebook.kernel.comm_manager.register_target(\n 'matplotlib',\n mpl.mpl_figure_comm\n );\n}\n", "text/plain": [ "" ] @@ -1196,8 +264,11 @@ } ], "metadata": { + "interpreter": { + "hash": "2146b6db258b20f3c29b7f1d7771ef33b30f307033b5e0e893928c1a552d47a9" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.9.5 ('env')", "language": "python", "name": "python3" }, @@ -1211,7 +282,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.9.5" }, "metadata": { "interpreter": {