diff --git a/docs/sound-level-meter.md b/docs/sound-level-meter.md new file mode 100644 index 00000000..c90211d1 --- /dev/null +++ b/docs/sound-level-meter.md @@ -0,0 +1,28 @@ +# MOSQITO Documentation +## Sound level meter functions + +### Introduction + +There are operations that are important. We need to be able to perform them to have a better understanding of the data with which we work and to be able to use them to calculate data of interest. For this are the sonometer functions. + +A step by step description of how to use MOSQITO to use the sonometer functions is given in [this tutorial](../tutorials/tuto_sound_level_meter.ipynb) + +### Validation of the implementation + +This section of the MoSQITo repository are mathematical accounts. For this reason, the validations have consisted of comparing two results: the results of the software and the simulated results in Excel. + +Accounts are backed by regulations. Among them we have ISO 1996 part 1, ISO 1996 part 2 and the international standard IEC 61672: 2014 (This is for the A weighting and the C weighting). + +We have taken three signals to carry out the calculations. These signals are located at ../tests/input and These are a white noise (349315__newagesoup__white-noise-10s.wav), a pink noise (349312__newagesoup__pink-noise-10s.wav) and a pure tone at 1000 Hz (554329__patobottos__beep-sound-of-1000-hz). + +For the functions that work with Thirds of an Octave, the three signals (input array) were introduced to the program. In the same way, the data of the signals are entered in an Excel in which the desired operation of the function has been replicated. If the function and Excel return the same result, it is shown that the function works well and returns the correct result. + +In the case of functions that work with temporary samples, only one of these three signals is entered and the procedure is the same, results are compared between the function and Excel. + +### References + +ISO 1996 - 1: Description, measurement and evaluation of environmental noise Part 1: Basic magnitudes and evaluation methods. + +ISO 1996 - 2: Description, measurement and evaluation of environmental noise Part 2: determination of sound pressure levels. + +IEC 61672-1:2014, Electroacoustics - Sound level meters - Part 1: Specifications. \ No newline at end of file diff --git a/logo.png b/logo.png index 6fd7ae85..b48d8da8 100644 Binary files a/logo.png and b/logo.png differ diff --git a/mosqito/functions/sound_level_meter/LN.py b/mosqito/functions/sound_level_meter/LN.py new file mode 100644 index 00000000..35fb03ee --- /dev/null +++ b/mosqito/functions/sound_level_meter/LN.py @@ -0,0 +1,46 @@ +# -*- coding: utf-8 -*- +""" +Created on Thu Jan 12 19:45:20 2023 + +@author: Igarciac117 +""" + +# Third party imports +import numpy as np + +# Local imports +from mosqito.utils.conversion import amp2db + +def LN(signal): + """Calculate the percentile value of the series of levels (dB) of the one signal. + + Parameters + ---------- + signal : numpy.array + time signal values [Pa] + + Outputs + ------- + percentiles : numpy.ndarray + The values in dB of L90, L50 and L25 of the signal. + """ + # Empty array to store the values in dB of the signal. + dB_values = np.zeros(signal.shape[0]) + # Performs the conversion to dB with all the values of the signal. + for i in range(signal.shape[0]): + #If the value is negative value. + if signal[i] <= 0: + # we convert it to positive. + signal[i] = np.sqrt(np.mean(signal[i] ** 2)) + # Conversion Pa to dB. + dB = amp2db(np.array(signal[i])) + # Save all values in dB of the third octave in another array. + dB_values[i] = dB + # Calculate the percentiles with the values. "q" of np.percentile = 100 - N (N of LN). + L90 = np.percentile(dB_values, 10,interpolation='linear') + L50 = np.percentile(dB_values, 50,interpolation='linear') + L25 = np.percentile(dB_values, 75,interpolation='linear') + # Save the calculated percentile values. + percentiles = np.array([L90,L50,L25]) + + return percentiles \ No newline at end of file diff --git a/mosqito/functions/sound_level_meter/max_level.py b/mosqito/functions/sound_level_meter/max_level.py new file mode 100644 index 00000000..c68f56e3 --- /dev/null +++ b/mosqito/functions/sound_level_meter/max_level.py @@ -0,0 +1,42 @@ +# -*- coding: utf-8 -*- +""" +Created on Wen Dic 1 18:08:08 2021 + +@author: Igarciac117 +""" + +# Third party imports +import numpy as np + +# Local imports +from mosqito.utils.conversion import amp2db + +def max_level(signal): + """Calculate the maximum value of the series of levels (dB) of the one signal. + + Parameters + ---------- + signal : numpy.array + time signal values + + Outputs + ------- + max_level : numpy.ndarray + return the maximum value of the signal values. + """ + # Empty array to store the values in dB of the signal. + dB_values = np.zeros(signal.shape[0]) + # Performs the conversion to dB with all the values of the signal. + for i in range(signal.shape[0]): + #If the value is negative value. + if signal[i] <= 0: + # we convert it to positive. + signal[i] = np.sqrt(np.mean(signal[i] ** 2)) + # Conversion Pa to dB. + dB = amp2db(np.array(signal[i])) + # Save all values in dB of the third octave in another array. + dB_values[i] = dB + # Save the maximum level. + max_level = np.array(max(dB_values)) + + return max_level \ No newline at end of file diff --git a/mosqito/functions/sound_level_meter/max_level_3oct.py b/mosqito/functions/sound_level_meter/max_level_3oct.py new file mode 100644 index 00000000..b9a79a09 --- /dev/null +++ b/mosqito/functions/sound_level_meter/max_level_3oct.py @@ -0,0 +1,66 @@ +# -*- coding: utf-8 -*- +""" +Created on Thu Jan 12 19:40:20 2023 + +@author: Igarciac117 +""" + +# Third party imports +import numpy as np + +# Local imports +from mosqito.sound_level_meter.noct_spectrum.noct_spectrum import noct_spectrum +from mosqito.utils.conversion import amp2db + +def max_level_3oct(data_all_signals, fs, f_min, f_max): + """Return the maximum value of the frequency bands you choose. Each one is calculated with the levels (dB) + of its band in the different signals. + + Parameters + ---------- + data_all_signals : numpy.ndarray + Array which each row corresponds to the data of a signal [Pa]. + fs : float + Sampling frequency [Hz]. + fmax : float + Max frequency band [Hz]. + fmin : float + Min frequency band [Hz]. + + Outputs + ------- + max_level_3oct : numpy.ndarray + The maximum values of each frequency band. + """ + # We initialize the array that stores the third octave values (in Pa) of the all signals ​​with the first signal. + spectrum_all_signals_Pa = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[0] + # We initialize the center frequencies of the third octaves with the first signal. + freq = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[1] + # We initialize the number of the signals. + num_signals = data_all_signals.shape[0] + # We initialize the number of frequency bands. + num_bands = freq.shape[0] + + # Calculate the value of the third octave in Pa of each signal. + for i in range(num_signals): + # We skip the first signal because we have initialized with it. + if i != 0: + # We calculate and save the values ​​of the third octaves of the signals + spectrum_all_signals_Pa = np.append(spectrum_all_signals_Pa,noct_spectrum(data_all_signals[i],fs,f_min,f_max)[0],axis=1) + + # Creating a list of zeros of the size of the frequency bands (to keep the maximum level values). + max_level_3oct = np.zeros(num_bands) + # Empty array to store the values in dB of the third octave whose maximum value is going to be calculated. + band_value_all_signals = np.zeros(num_signals) + # For each frequency band you perform the operation. + for i in range(num_bands): + # Performs the conversion to dB with all the values of the frequency band in the different signals. + for j in range(num_signals): + # Conversion Pa to dB. + dB = amp2db(np.array(spectrum_all_signals_Pa[i][j])) + # Save all values in dB of the third octave in another array. + band_value_all_signals[j] = dB + # Calculate and keep the maximum value found in the array. That value will be the maximum of the third of an octave. + max_level_3oct[i] = max(band_value_all_signals) + + return max_level_3oct \ No newline at end of file diff --git a/mosqito/functions/sound_level_meter/min_level.py b/mosqito/functions/sound_level_meter/min_level.py new file mode 100644 index 00000000..710e9b7b --- /dev/null +++ b/mosqito/functions/sound_level_meter/min_level.py @@ -0,0 +1,42 @@ +# -*- coding: utf-8 -*- +""" +Created on Thu Jan 12 19:44:20 2023 + +@author: Igarciac117 +""" + +# Third party imports +import numpy as np + +# Local imports +from mosqito.utils.conversion import amp2db + +def min_level(signal): + """Calculate the minimum value of the series of levels (dB) of the one signal. + + Parameters + ---------- + signal : numpy.array + time signal values + + Outputs + ------- + min_level : numpy.ndarray + return the minimum value of the signal values. + """ + # Empty array to store the values in dB of the signal. + dB_values = np.zeros(signal.shape[0]) + # Performs the conversion to dB with all the values of the signal. + for i in range(signal.shape[0]): + #If the value is negative value. + if signal[i] <= 0: + # we convert it to positive. + signal[i] = np.sqrt(np.mean(signal[i] ** 2)) + # Conversion Pa to dB. + dB = amp2db(np.array(signal[i])) + # Save all values in dB of the third octave in another array. + dB_values[i] = dB + # Save the minimum level. + min_level = np.array(min(dB_values)) + + return min_level \ No newline at end of file diff --git a/mosqito/functions/sound_level_meter/min_level_3oct.py b/mosqito/functions/sound_level_meter/min_level_3oct.py new file mode 100644 index 00000000..85c5891f --- /dev/null +++ b/mosqito/functions/sound_level_meter/min_level_3oct.py @@ -0,0 +1,66 @@ +# -*- coding: utf-8 -*- +""" +Created on Thu Jan 12 19:43:20 2023 + +@author: Igarciac117 +""" + +# Third party imports +import numpy as np + +# Local imports +from mosqito.sound_level_meter.noct_spectrum.noct_spectrum import noct_spectrum +from mosqito.utils.conversion import amp2db + +def min_level_3oct(data_all_signals, fs, f_min, f_max): + """Return the minimum value of the frequency bands you choose. Each one is calculated with the levels (dB) + of its band in the different signals. + + Parameters + ---------- + data_all_signals : numpy.ndarray + Array which each row corresponds to the data of a signal [Pa]. + fs : float + Sampling frequency [Hz]. + fmax : float + Max frequency band [Hz]. + fmin : float + Min frequency band [Hz]. + + Outputs + ------- + min_level_3oct : numpy.ndarray + The minimum values of each frequency band. + """ + # We initialize the array that stores the third octave values (in Pa) of the all signals ​​with the first signal. + spectrum_all_signals_Pa = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[0] + # We initialize the center frequencies of the third octaves with the first signal. + freq = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[1] + # We initialize the number of the signals. + num_signals = data_all_signals.shape[0] + # We initialize the number of frequency bands. + num_bands = freq.shape[0] + + # Calculate the value of the third octave in Pa of each signal. + for i in range(num_signals): + # We skip the first signal because we have initialized with it. + if i != 0: + # We calculate and save the values ​​of the third octaves of the signals + spectrum_all_signals_Pa = np.append(spectrum_all_signals_Pa,noct_spectrum(data_all_signals[i],fs,f_min,f_max)[0],axis=1) + + # Creating a list of zeros of the size of the frequency bands (to keep the maximum level values). + min_level_3oct = np.zeros(num_bands) + # Empty array to store the values in dB of the third octave whose maximum value is going to be calculated. + band_value_all_signals = np.zeros(num_signals) + # For each frequency band you perform the operation. + for i in range(num_bands): + # Performs the conversion to dB with all the values of the frequency band in the different signals. + for j in range(num_signals): + # Conversion Pa to dB. + dB = amp2db(np.array(spectrum_all_signals_Pa[i][j])) + # Save all values in dB of the third octave in another array. + band_value_all_signals[j] = dB + # Calculate and keep the maximum value found in the array. That value will be the maximum of the third of an octave. + min_level_3oct[i] = min(band_value_all_signals) + + return min_level_3oct \ No newline at end of file diff --git a/mosqito/functions/sound_level_meter/spectrum2dBA_2.py b/mosqito/functions/sound_level_meter/spectrum2dBA_2.py new file mode 100644 index 00000000..0e2d402d --- /dev/null +++ b/mosqito/functions/sound_level_meter/spectrum2dBA_2.py @@ -0,0 +1,114 @@ +# -*- coding: utf-8 -*- +""" +Created on Mon Nov 15 16:37:08 2021 + +@author: Igarciac117 +""" + +import numpy as np + +def spectrum2dBA_2(spectrum, freq_axis): + """A_weighting dB ponderation of a spectrum according to CEI 61672:2003 + + Third-octave spectrum are directly calculated, other are calculated + using linear interpolation. + + Parameters + ---------- + spectrum: numpy.array + input spectrum + freq_axis: numpy.ndarray + Corresponding preferred third octave band center frequencies + + Outputs + ------- + spectrum_dBA : numpy.ndarray + spectrum in dBA. + """ + + # Ponderation coefficients from the standard + A_standard = np.array( + [ + -70.4, + -63.4, + -56.7, + -50.5, + -44.7, + -39.4, + -34.6, + -30.2, + -26.2, + -22.5, + -19.1, + -16.1, + -13.4, + -10.9, + -8.6, + -6.6, + -4.8, + -3.2, + -1.9, + -0.8, + 0, + 0.6, + 1, + 1.2, + 1.3, + 1.2, + 1, + 0.5, + -0.1, + -1.1, + -2.5, + -4.3, + -6.6, + -9.3, + ] + ) + + freq_standard = np.array( + [ + 10, + 12.5, + 16, + 20, + 25, + 31.5, + 40, + 50, + 63, + 80, + 100, + 125, + 160, + 200, + 250, + 315, + 400, + 500, + 630, + 800, + 1000, + 1250, + 1600, + 2000, + 2500, + 3150, + 4000, + 5000, + 6300, + 8000, + 10000, + 12500, + 16000, + 20000, + ] + ) + + A_pond = np.interp(freq_axis, freq_standard, A_standard) + + spectrum_dBA = np.zeros(spectrum.shape) + for i in range(spectrum.shape[0]): + spectrum_dBA[i] = spectrum[i] + A_pond[i] + + return spectrum_dBA diff --git a/mosqito/functions/sound_level_meter/spectrum2dBC.py b/mosqito/functions/sound_level_meter/spectrum2dBC.py new file mode 100644 index 00000000..9e010b8b --- /dev/null +++ b/mosqito/functions/sound_level_meter/spectrum2dBC.py @@ -0,0 +1,114 @@ +# -*- coding: utf-8 -*- +""" +Created on Mon Nov 15 16:37:08 2021 + +@author: Igarciac117 +""" + +import numpy as np + +def spectrum2dBC(spectrum, freq_axis): + """C_weighting dB ponderation of a spectrum according to CEI 61672:2003 + + Third-octave spectrum are directly calculated, other are calculated + using linear interpolation. + + Parameters + ---------- + spectrum: numpy.array + input spectrum + freq_axis: numpy.ndarray + Corresponding preferred third octave band center frequencies + + Outputs + ------- + spectrum_dBC : numpy.ndarray + spectrum in dBC. + """ + + # Ponderation coefficients from the standard + C_standard = np.array( + [ + -14.3, + -11.2, + -8.5, + -6.2, + -4.4, + -3.0, + -2.0, + -1.3, + -0.8, + -0.5, + -0.3, + -0.2, + -0.1, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0, + 0.0, + -0.1, + -0.2, + -0.3, + -0.5, + -0.8, + -1.3, + -2.0, + -3.0, + -4.4, + -6.2, + -8.5, + -11.2, + ] + ) + + freq_standard = np.array( + [ + 10, + 12.5, + 16, + 20, + 25, + 31.5, + 40, + 50, + 63, + 80, + 100, + 125, + 160, + 200, + 250, + 315, + 400, + 500, + 630, + 800, + 1000, + 1250, + 1600, + 2000, + 2500, + 3150, + 4000, + 5000, + 6300, + 8000, + 10000, + 12500, + 16000, + 20000, + ] + ) + + C_pond = np.interp(freq_axis, freq_standard, C_standard) + + spectrum_dBC = np.zeros(spectrum.shape) + for i in range(spectrum.shape[0]): + spectrum_dBC[i] = spectrum[i] + C_pond[i] + + return spectrum_dBC \ No newline at end of file diff --git a/mosqito/functions/sound_level_meter/spectrum_3oct_dB.py b/mosqito/functions/sound_level_meter/spectrum_3oct_dB.py new file mode 100644 index 00000000..306495dc --- /dev/null +++ b/mosqito/functions/sound_level_meter/spectrum_3oct_dB.py @@ -0,0 +1,68 @@ +# -*- coding: utf-8 -*- +""" +Created on Thu Jan 12 19:37:20 2023 + +@author: Igarciac117 +""" + +# Third party imports +import numpy as np +import math + +# Local imports +from mosqito.sound_level_meter.noct_spectrum.noct_spectrum import noct_spectrum +from mosqito.utils.conversion import amp2db + +def spectrum_3oct_dB(data_all_signals, fs, f_min, f_max): + """Calculates, in dB, the spectrum in Thirds of octaves of a .wav file. + You can enter different fragments of the same .wav file at the same time or enter a single .wav file. + + Parameters + ---------- + data_all_signals : numpy.ndarray + Array which each row corresponds to the data of a signal [Pa]. + fs : float + Sampling frequency [Hz]. + fmax : float + Max frequency band [Hz]. + fmin : float + Min frequency band [Hz]. + + Outputs + ------- + spectrum_3oct_dB : numpy.ndarray + Third octave spectrum in dB. + """ + + # We initialize the array that stores the third octave values (in Pa) of the all signals ​​with the first signal. + spectrum_all_signals_Pa = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[0] + # We initialize the center frequencies of the third octaves with the first signal. + freq = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[1] + # We initialize the number of the signals. + num_signals = data_all_signals.shape[0] + # We initialize the number of frequency bands. + num_bands = freq.shape[0] + + # Calculate the value of the third octave of each signal. + for i in range(num_signals): + # We skip the first signal because we have initialized with it. + if i != 0: + # We calculate and save the values in Pa ​​of the third octaves of the signals. + spectrum_all_signals_Pa = np.append(spectrum_all_signals_Pa,noct_spectrum(data_all_signals[i],fs,f_min,f_max)[0],axis=1) + + # Creating a list of zeros of the size of the frequency bands (to keep the Leq values). + spectrum_3oct_dB = np.zeros(num_bands) + # For each frequency band you perform the operation. + for i in range(num_bands): + sum = 0 + # Performs the summation with all the values of the frequency band in the different signals. + for j in range(num_signals): + # conversion Pa to dB + dB = amp2db(np.array(spectrum_all_signals_Pa[i][j])) + # Operation: summation(10^(level(db)[i]/10)) + sum = sum + 10.0**(dB/10.0) + # Keep the Leq value in the box corresponding to the frequency band from which the calculation is being made. + # Operation: 10 x log(base 10)[1/number of samples x sum] + spectrum_3oct_dB[i] = 10.0 * math.log(((1/num_signals)*sum),10) + + return spectrum_3oct_dB \ No newline at end of file diff --git a/mosqito/functions/sound_level_meter/spectrum_3oct_dBC.py b/mosqito/functions/sound_level_meter/spectrum_3oct_dBC.py new file mode 100644 index 00000000..a8dde95c --- /dev/null +++ b/mosqito/functions/sound_level_meter/spectrum_3oct_dBC.py @@ -0,0 +1,90 @@ +# -*- coding: utf-8 -*- +""" +Created on Thu Jan 12 19:36:20 2023 + +@author: Igarciac117 +""" + +# Third party imports +import numpy as np +import math + +# Local imports +from spectrum2dBC import spectrum2dBC +from mosqito.sound_level_meter.noct_spectrum.noct_spectrum import noct_spectrum +from mosqito.utils.conversion import amp2db + +def spectrum_3oct_dBC (data_all_signals, fs, f_min, f_max): + """Calculates, in dBC, the spectrum in Thirds of octaves of a .wav file. + You can enter different fragments of the same .wav file at the same time or enter a single .wav file. + + Parameters + ---------- + data_all_signals : numpy.ndarray + Array which each row corresponds to the data of a signal [Pa]. + fs : float + Sampling frequency [Hz]. + fmax : float + Max frequency band [Hz]. + fmin : float + Min frequency band [Hz]. + + Outputs + ------- + spectrum_3oct_dBC : numpy.ndarray + Third octave spectrum in dBC. + """ + # We initialize the array that stores the third octave values (in Pa) of the all signals ​​with the first signal. + spectrum_all_signals_Pa = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[0] + # We initialize the center frequencies of the third octaves with the first signal. + freq = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[1] + # We initialize the number of the signals. + num_signals = data_all_signals.shape[0] + # We initialize the number of frequency bands. + num_bands = freq.shape[0] + + # Calculate the value of the third octave in Pa of each signal. + for i in range(num_signals): + # We skip the first signal because we have initialized with it. + if i != 0: + # We calculate and save the values ​​of the third octaves of the signals + spectrum_all_signals_Pa = np.append(spectrum_all_signals_Pa,noct_spectrum(data_all_signals[i],fs,f_min,f_max)[0],axis=1) + # We initialize the size of the array in which the data is stored. + array_shape = spectrum_all_signals_Pa.shape + + # Empty array to store the values in dB of the third octave of the all signals. + spectrum_all_signals_dB = np.zeros(array_shape) + # For each frequency band you perform the operation. + for i in range(num_bands): + # Performs the conversion to dB with all the values of the frequency band in the different signals. + for j in range(num_signals): + # Conversion Pa to dB. + dB = amp2db(np.array(spectrum_all_signals_Pa[i][j])) + # Save all values in dB of the third octave in another array. + spectrum_all_signals_dB[i][j] = dB + + # Empty array to store the values in dBC of the third octave of the all signals. + spectrum_all_signals_dBC = np.zeros(array_shape) + # For each signal you perform the operation. + for i in range(num_signals): + # conversion dB to dBC of the all third octave values. + dBC = spectrum2dBC(np.array(spectrum_all_signals_dB[:,i]), freq) + # For each frequency band you perform the operation. + for j in range(num_bands): + # Save all values in dBC of the third octave in another array. + spectrum_all_signals_dBC[j][i] = dBC[j] + + # Creating a list of zeros of the size of the frequency bands (to keep the LCeq values). + spectrum_3oct_dBC = np.zeros(num_bands) + # For each frequency band you perform the operation. + for i in range(num_bands): + sum = 0 + # Performs the summation with all the values of the frequency band in the different signals. + for j in range(num_signals): + # Operation: summation(10^(level(db)[i]/10)) + sum = sum + 10.0**(spectrum_all_signals_dBC[i][j]/10.0) + # Keep the LCeq value in the box corresponding to the frequency band from which the calculation is being made. + # Operation: 10 x log(base 10)[1/number of samples x sum] + spectrum_3oct_dBC[i] = 10.0 * math.log(((1/num_signals)*sum),10) + + return spectrum_3oct_dBC \ No newline at end of file diff --git a/mosqito/functions/sound_level_meter/spectum_3oct_dBA.py b/mosqito/functions/sound_level_meter/spectum_3oct_dBA.py new file mode 100644 index 00000000..e352d5c6 --- /dev/null +++ b/mosqito/functions/sound_level_meter/spectum_3oct_dBA.py @@ -0,0 +1,90 @@ +# -*- coding: utf-8 -*- +""" +Created on Thu Jan 12 19:31:20 2023 + +@author: Igarciac117 +""" + +# Third party imports +import numpy as np +import math + +# Local imports +from spectrum2dBA_2 import spectrum2dBA_2 +from mosqito.sound_level_meter.noct_spectrum.noct_spectrum import noct_spectrum +from mosqito.utils.conversion import amp2db + +def spectrum_3oct_dBA (data_all_signals, fs, f_min, f_max): + """Calculates, in dBA, the spectrum in Thirds of octaves of a .wav file. + You can enter different fragments of the same .wav file at the same time or enter a single .wav file. + + Parameters + ---------- + data_all_signals : numpy.ndarray + Array which each row corresponds to the data of a signal [Pa]. + fs : float + Sampling frequency [Hz]. + fmax : float + Max frequency band [Hz]. + fmin : float + Min frequency band [Hz]. + + Outputs + ------- + spectrum_3oct_dBA : numpy.ndarray + Third octave spectrum in dBA. + """ + # We initialize the array that stores the third octave values (in Pa) of the all signals ​​with the first signal. + spectrum_all_signals_Pa = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[0] + # We initialize the center frequencies of the third octaves with the first signal. + freq = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[1] + # We initialize the number of the signals. + num_signals = data_all_signals.shape[0] + # We initialize the number of frequency bands. + num_bands = freq.shape[0] + + # Calculate the value of the third octave in Pa of each signal. + for i in range(num_signals): + # We skip the first signal because we have initialized with it. + if i != 0: + # We calculate and save the values ​​of the third octaves of the signals + spectrum_all_signals_Pa = np.append(spectrum_all_signals_Pa,noct_spectrum(data_all_signals[i],fs,f_min,f_max)[0],axis=1) + # We initialize the size of the array in which the data is stored. + array_shape = spectrum_all_signals_Pa.shape + + # Empty array to store the values in dB of the third octave of the all signals. + spectrum_all_signals_dB = np.zeros(array_shape) + # For each frequency band you perform the operation. + for i in range(num_bands): + # Performs the conversion to dB with all the values of the frequency band in the different signals. + for j in range(num_signals): + # Conversion Pa to dB. + dB = amp2db(np.array(spectrum_all_signals_Pa[i][j])) + # Save all values in dB of the third octave in another array. + spectrum_all_signals_dB[i][j] = dB + + # Empty array to store the values in dBA of the third octave of the all signals. + spectrum_all_signals_dBA = np.zeros(array_shape) + # For each signal you perform the operation. + for i in range(num_signals): + # conversion dB to dBA of the all third octave values. + dBA = spectrum2dBA_2(np.array(spectrum_all_signals_dB[:,i]), freq) + # For each frequency band you perform the operation. + for j in range(num_bands): + # Save all values in dBA of the third octave in another array. + spectrum_all_signals_dBA[j][i] = dBA[j] + + # Creating a list of zeros of the size of the frequency bands (to keep the LAeq values). + spectrum_3oct_dBA = np.zeros(num_bands) + # For each frequency band you perform the operation. + for i in range(num_bands): + sum = 0 + # Performs the summation with all the values of the frequency band in the different signals. + for j in range(num_signals): + # Operation: summation(10^(level(db)[i]/10)) + sum = sum + 10.0**(spectrum_all_signals_dBA[i][j]/10.0) + # Keep the LAeq value in the box corresponding to the frequency band from which the calculation is being made. + # Operation: 10 x log(base 10)[1/number of samples x sum] + spectrum_3oct_dBA[i] = 10.0 * math.log(((1/num_signals)*sum),10) + + return spectrum_3oct_dBA \ No newline at end of file diff --git a/mosqito/utils/conversion.py b/mosqito/utils/conversion.py index 27dd9338..f28910e2 100644 --- a/mosqito/utils/conversion.py +++ b/mosqito/utils/conversion.py @@ -26,7 +26,7 @@ def db2amp(dB, ref=1): return np.power(10, 0.05 * dB) * ref -def amp2db(amp, ref=1): +def amp2db(amp, ref=2*(10**-5)): """Conversion of an amplitude value into dB Parameters: diff --git a/tests/input/349312__newagesoup__pink-noise-10s.wav b/tests/input/349312__newagesoup__pink-noise-10s.wav new file mode 100644 index 00000000..10f7ab2f Binary files /dev/null and b/tests/input/349312__newagesoup__pink-noise-10s.wav differ diff --git a/tests/input/349315__newagesoup__white-noise-10s.wav b/tests/input/349315__newagesoup__white-noise-10s.wav new file mode 100644 index 00000000..cd12b9b7 Binary files /dev/null and b/tests/input/349315__newagesoup__white-noise-10s.wav differ diff --git a/tests/input/554329__patobottos__beep-sound-of-1000-hz.wav b/tests/input/554329__patobottos__beep-sound-of-1000-hz.wav new file mode 100644 index 00000000..477c517b Binary files /dev/null and b/tests/input/554329__patobottos__beep-sound-of-1000-hz.wav differ diff --git a/tutorials/tuto_sound_level_meter.ipynb b/tutorials/tuto_sound_level_meter.ipynb new file mode 100644 index 00000000..c606b578 --- /dev/null +++ b/tutorials/tuto_sound_level_meter.ipynb @@ -0,0 +1,1164 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "toc": true + }, + "source": [ + "

Table of Contents

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# How to compute the functions of sound level meter\n", + "This tutorial explains how to use MoSQITo to compute the functions of the sound level meter. There are two types of functions: Those that work with Third Octaves and those that work with time samples. Users can calculate either by focusing on frequency bands or by focusing on representative values of a signal. \n", + "\n", + "## Types of calculations\n", + "### Calculate by third octave \n", + "This tutorial explains how these functions operate. Each function calculates the value given by the function name from a .wav file (e.g. spectrum_3oct_dB calculates the spectrum in Thirds of an Octave, in dB, from a .wav file). These functions are recognisable because they have the suffix \"_3oct\" written in the name.\n", + "\n", + "This kind of functions have the peculiarity of being able to split your .wav file in as many time segments as you want, the only condition is that the segments must have the same duration. For example if you have a 30 seconds .wav file you can split it into three .wav files of 10 seconds each and then decide which of these fragments to insert in the function. This allows you to \"delete\" one of the fragments, this, for example, you may want to do if this fragment is contaminated.\n", + "\n", + "If you don't want to fragment it, you would simply enter the .wav without fragmenting it. Let's create an input array for these functions:\n", + "\n", + "\n", + "\n", + "#### Attention!!!!!\n", + "\n", + "The signals entered as input parameters for the calculation must be the parts OF THE SAME SIGNAL (they must all be from the same .wav file), three different signals are used in the tutorial just as an example. For the functions to work correctly, our .wav file must be split into segments of the same length. For example, split a 30 second file into three 10 second files. These three new .wav files correspond to the input signals entered." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'mosqito.utils.load'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_7524\\3171805681.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;31m# Local imports\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0mmosqito\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mload\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mload\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[1;31m# Define the path of all the signals you want for the input array. In this case we test with 3 different signals.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'mosqito.utils.load'" + ] + } + ], + "source": [ + "# Third party imports\n", + "import numpy as np\n", + "\n", + "# Local imports\n", + "from mosqito.utils.load import load\n", + "\n", + "# Define the path of all the signals you want for the input array. In this case we test with 3 different signals.\n", + "#Pink noise\n", + "path_1 = \"../tests/input/349312__newagesoup__pink-noise-10s.wav\"\n", + "#White noise\n", + "path_2 = \"../tests/input/349315__newagesoup__white-noise-10s.wav\"\n", + "#Pure tone at 1000 HZ\n", + "path_3 = \"../tests/input/554329__patobottos__beep-sound-of-1000-hz.wav\"\n", + "\n", + "# We get the data in Pa and the sampling frequency of all the signals with the help of the Load function.\n", + "#Pink noise\n", + "print (\"First signal:\")\n", + "sig_1, fs_1 = load(path_1)\n", + "print(\"----------------------\")\n", + "#White noise\n", + "print (\"Second signal:\")\n", + "sig_2, fs_2 = load(path_2)\n", + "print(\"----------------------\")\n", + "#Pure tone at 1000 Hz\n", + "print (\"Third signal:\")\n", + "sig_3, fs_3 = load(path_3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is what the input array looks like:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-2.63055563e-02 1.93548203e-03 1.18016362e-01 ... -2.76583076e-01\n", + " -2.64079571e-01 -2.76391864e-01]\n", + " [ 6.90580488e-01 2.10633397e-01 4.89044786e-01 ... 5.37475109e-01\n", + " 3.64259720e-01 4.63660956e-01]\n", + " [ 3.05185095e-05 1.04338428e-01 2.07123525e-01 ... -3.06022273e-01\n", + " -2.07225289e-01 -1.04296308e-01]]\n" + ] + } + ], + "source": [ + "# Input array with the three signals.\n", + "data_all_signals = np.stack((sig_1,sig_2,sig_3))\n", + "# Show the input array.\n", + "print(data_all_signals)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All the functions that work with Tercios de Octave internally carry out a conversion from temporary samples in Pa to Tercios de octave in Pa. This conversion is shown here:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Local imports\n", + "from mosqito.sound_level_meter.noct_spectrum.noct_spectrum import noct_spectrum\n", + "\n", + "# We initialize the frequency range that we want to study, f_min is the frequency of the lower limit and\n", + "# f_max the frequency of the upper limit.\n", + "f_min = 250\n", + "f_max = 20000\n", + "# We initialize the sampling frequency (it is returned by the load function, fs_1 is the sampling frequency\n", + "# of signal 1 in section 1.1 Calculate by third octave).\n", + "fs = fs_1\n", + "\n", + "# We initialize the array that stores the third octave values (in Pa) of the all signals ​​with the first signal.\n", + "spectrum_all_signals_Pa = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[0]\n", + "# We initialize the number of the signals.\n", + "num_signals = data_all_signals.shape[0]\n", + "\n", + "# Calculate the value of the third octave of each signal.\n", + "for i in range(num_signals):\n", + " # We skip the first signal because we have initialized with it.\n", + " if i != 0:\n", + " # We calculate and save the values in Pa ​​of the third octaves of the signals.\n", + " spectrum_all_signals_Pa = np.append(spectrum_all_signals_Pa,noct_spectrum(data_all_signals[i],fs,f_min,f_max)[0],axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculate by time samples\n", + "In this tutorial for the calculations all temporary samples collected are used. Each sample is collected in a time and has its value. With this values (Pa) is calculate the signal functions of this sound level meter. Will return an array with the value have been calculated, the calculations are made for all samples so it is only a representative or generic value for the input signal.\n", + "\n", + "An input array is needed, all the values in Pa of the time samples of a signal must be on the same row. Let's create an input array for these functions: " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Signal:\n", + "[Info] Multichannel signal loaded. Keeping only first channel\n", + "[Info] A calibration of 1 Pa/FS is considered\n" + ] + } + ], + "source": [ + "# Third party imports\n", + "import numpy as np\n", + "\n", + "# Local imports\n", + "from mosqito.utils.load import load\n", + "\n", + "# Define the path of the signal you want for the input array. In this case we test.\n", + "#Pink noise\n", + "path = \"../tests/input/349312__newagesoup__pink-noise-10s.wav\"\n", + "\n", + "# We get the data in Pa and the sampling frequency of all the signals with the help of the Load function.\n", + "#Pink noise 60 dB (21 is the Wab_calib value for this particular .wav).\n", + "print (\"Signal:\")\n", + "signal, fs = load(path)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is how the input array for these functions finally has to look like. It is just an array with the values in Pa of the level of each sample." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Signal: \n", + "[-0.02630556 0.00193548 0.11801636 ... -0.27658308 -0.26407957\n", + " -0.27639186]\n", + "Sample rate: \n", + "48000\n" + ] + } + ], + "source": [ + "# Import useful packages\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"Signal: \")\n", + "print(signal)\n", + "\n", + "print(\"Sample rate: \")\n", + "print(fs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Functions of the sound level meter\n", + "Here explain all the functions available in the sound level meter and what array will each of them return." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### spectrum_3oct_dB\n", + "This function is only available for calculation in frequency bands (_3oct).\n", + "\n", + "Calculates, in dBC, the spectrum in Thirds of octaves of a .wav file. You can enter different fragments of the same .wav file at the same time or enter a single .wav file." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Third party imports\n", + "import math\n", + "\n", + "# Local imports\n", + "from mosqito.utils.conversion import amp2db\n", + "\n", + "# We initialize the center frequencies of the third octaves with the first signal.\n", + "freq = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[1]\n", + "# We initialize the number of frequency bands.\n", + "num_bands = freq.shape[0]\n", + " \n", + "# Creating a list of zeros of the size of the frequency bands (to keep the spectrum_3oct_dB values).\n", + "spectrum_3oct_dB = np.zeros(num_bands)\n", + "# For each frequency band you perform the operation.\n", + "for i in range(num_bands): \n", + " sum = 0\n", + " # Performs the summation with all the values of the frequency band in the different signals.\n", + " for j in range(num_signals):\n", + " # conversion Pa to dB\n", + " dB = amp2db(np.array(spectrum_all_signals_Pa[i][j]), 2*(10**-5))\n", + " # Operation: summation(10^(level(db)[i]/10))\n", + " sum = sum + 10.0**(dB/10.0)\n", + " # Keep the spectrum_3oct_dB value in the box corresponding to the frequency band from which the calculation is being made.\n", + " # Operation: 10 x log(base 10)[1/number of samples x sum]\n", + " spectrum_3oct_dB[i] = 10.0 * math.log(((1/num_signals)*sum),10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally with the dB values, the averaging of levels between the .wav fragments is performed to build the spectrum. Returns the spectrum in Thirds of Octave in dB." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Import useful packages\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"spectrum_3oct_dB: \")\n", + "print(spectrum_3oct_dB)\n", + "\n", + "print(\"Freq: \")\n", + "print(freq)\n", + "\n", + "#x_freq = ['25', '31.5', '40', '50', '63', '80', '100', '125', '160', '200', '250', '315',\n", + "# '400', '500', '630', '800', '1000', '1250', '1600', '2000', '2500', '3150', '4000', '5000', '6300', '8000',\n", + "# '10000', '12500']\n", + "x_freq = ['250', '315','400', '500', '630', '800', '1000', '1250', '1600', '2000', '2500', '3150', '4000',\n", + " '5000', '6300', '8000','10000', '12500', '16000', '20000']\n", + "y_values = spectrum_3oct_dB\n", + "\n", + "# The figure is created\n", + "fig = plt.figure ()\n", + "# The object inside the figure is created\n", + "ax = fig.add_subplot (1, 1, 1)\n", + "\n", + "# Legend on the y axis\n", + "plt.ylabel ('Level dB')\n", + "# Legend on the x axis\n", + "plt.xlabel ('Frequency Hz')\n", + "# Graphic Title\n", + "plt.title ('spectrum_3oct_dB result in Thirds of Octave')\n", + "\n", + "# Bar graph is created\n", + "ax.bar (x_freq, y_values, color = \"C0\")\n", + "# Rotation of the x axis data\n", + "ax.set_xticklabels (x_freq, rotation = 75, fontsize = 9)\n", + "# Show the graph \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### spectrum_3oct_dBA\n", + "\n", + "This function is only available for calculation in frequency bands (_3oct).\n", + "\n", + "Calculates, in dBC, the spectrum in Thirds of octaves of a .wav file. You can enter different fragments of the same .wav file at the same time or enter a single .wav file. In order to convert dB into dBA we use an internal function of the Mosqito: spectrum2dBA_2." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Local imports\n", + "from mosqito.functions.sound_level_meter.spectrum2dBA_2 import spectrum2dBA_2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The input array is the temporary values in Pa. The operation of transforming them into Third octaves in Pa is performed (it was shown in 1.1 Calculate by third octave). Then the conversion from Pa to dB:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Local imports\n", + "from mosqito.utils.conversion import amp2db\n", + "\n", + "# We initialize the size of the array in which the data is stored.\n", + "array_shape = spectrum_all_signals_Pa.shape\n", + "# We initialize the center frequencies of the third octaves with the first signal.\n", + "freq = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[1]\n", + "# We initialize the number of frequency bands.\n", + "num_bands = freq.shape[0]\n", + "\n", + "# Empty array to store the values in dB of the third octave of the all signals.\n", + "spectrum_all_signals_dB = np.zeros(array_shape)\n", + "# For each frequency band you perform the operation.\n", + "for i in range(num_bands):\n", + " # Performs the conversion to dB with all the values of the frequency band in the different signals.\n", + " for j in range(num_signals): \n", + " # Conversion Pa to dB.\n", + " dB = amp2db(np.array(spectrum_all_signals_Pa[i][j]))\n", + " # Save all values in dB of the third octave in another array.\n", + " spectrum_all_signals_dB[i][j] = dB" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we perform the dB to dBA conversion:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Empty array to store the values in dBA of the third octave of the all signals.\n", + "spectrum_all_signals_dBA = np.zeros(array_shape)\n", + "# For each signal you perform the operation.\n", + "for i in range(num_signals):\n", + " # conversion dB to dBA of the all third octave values.\n", + " dBA = spectrum2dBA_2(np.array(spectrum_all_signals_dB[:,i]), freq)\n", + " # For each frequency band you perform the operation.\n", + " for j in range(num_bands):\n", + " # Save all values in dBA of the third octave in another array.\n", + " spectrum_all_signals_dBA[j][i] = dBA[j]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally with the dBA values, the averaging of levels between the .wav fragments is performed to build the spectrum. Returns the spectrum in Thirds of Octave in dBA." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Third party imports\n", + "import math\n", + "\n", + "# Creating a list of zeros of the size of the frequency bands (to keep the spectrum_3oct_dBA values).\n", + "spectrum_3oct_dBA = np.zeros(num_bands)\n", + "# For each frequency band you perform the operation.\n", + "for i in range(num_bands): \n", + " sum = 0\n", + " # Performs the summation with all the values of the frequency band in the different signals.\n", + " for j in range(num_signals):\n", + " # Operation: summation(10^(level(dbA)[i]/10))\n", + " sum = sum + 10.0**(spectrum_all_signals_dBA[i][j]/10.0)\n", + " # Keep the spectrum_3oct_dBA value in the box corresponding to the frequency band from which the calculation is being made.\n", + " # Operation: 10 x log(base 10)[1/number of samples x sum]\n", + " spectrum_3oct_dBA[i] = 10.0 * math.log(((1/num_signals)*sum),10) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Returns spectrum_3oct_dBA, which is an array with as many values as there are frequency bands being operated. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Import useful packages\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"spectrum_3oct_dBA: \")\n", + "print(spectrum_3oct_dBA)\n", + "\n", + "print(\"Freq: \")\n", + "print(freq)\n", + "\n", + "#x_freq = ['25', '31.5', '40', '50', '63', '80', '100', '125', '160', '200', '250', '315',\n", + "# '400', '500', '630', '800', '1000', '1250', '1600', '2000', '2500', '3150', '4000', '5000', '6300', '8000',\n", + "# '10000', '12500']\n", + "x_freq = ['250', '315','400', '500', '630', '800', '1000', '1250', '1600', '2000', '2500', '3150', '4000',\n", + " '5000', '6300', '8000','10000', '12500', '16000', '20000']\n", + "y_values = spectrum_3oct_dBA\n", + "\n", + "# The figure is created\n", + "fig = plt.figure ()\n", + "# The object inside the figure is created\n", + "ax = fig.add_subplot (1, 1, 1)\n", + "\n", + "# Legend on the y axis\n", + "plt.ylabel ('Level dBA')\n", + "# Legend on the x axis\n", + "plt.xlabel ('Frequency Hz')\n", + "# Graphic Title\n", + "plt.title ('spectrum_3oct_dBA result in Thirds of Octave')\n", + "\n", + "# Bar graph is created\n", + "ax.bar (x_freq, y_values, color = \"C0\")\n", + "# Rotation of the x axis data\n", + "ax.set_xticklabels (x_freq, rotation = 75, fontsize = 9)\n", + "# Show the graph \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " ### spectrum_3oct_dBC\n", + "This function is only available for calculation in frequency bands (_3oct).\n", + "\n", + "Calculates, in dBC, the spectrum in Thirds of octaves of a .wav file. You can enter different fragments of the same .wav file at the same time or enter a single .wav file. In order to convert dB into dBC we use an internal function of the Mosqito: spectrum2dBC." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Local imports\n", + "from mosqito.functions.sound_level_meter.spectrum2dBC import spectrum2dBC" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The input array is the temporary values in Pa. The operation of transforming them into Third octaves in Pa is performed (it was shown in 1.1 Calculate by third octave). Then the conversion from Pa to dB:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Local imports\n", + "from mosqito.utils.conversion import amp2db\n", + "\n", + "# We initialize the size of the array in which the data is stored.\n", + "array_shape = spectrum_all_signals_Pa.shape\n", + "# We initialize the center frequencies of the third octaves with the first signal.\n", + "freq = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[1]\n", + "# We initialize the number of frequency bands.\n", + "num_bands = freq.shape[0]\n", + "\n", + "# Empty array to store the values in dB of the third octave of the all signals.\n", + "spectrum_all_signals_dB = np.zeros(array_shape)\n", + "# For each frequency band you perform the operation.\n", + "for i in range(num_bands):\n", + " # Performs the conversion to dB with all the values of the frequency band in the different signals.\n", + " for j in range(num_signals): \n", + " # Conversion Pa to dB.\n", + " dB = amp2db(np.array(spectrum_all_signals_Pa[i][j]))\n", + " # Save all values in dB of the third octave in another array.\n", + " spectrum_all_signals_dB[i][j] = dB" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we perform the dB to dBC conversion:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Empty array to store the values in dBC of the third octave of the all signals.\n", + "spectrum_all_signals_dBC = np.zeros(array_shape)\n", + "# For each signal you perform the operation.\n", + "for i in range(num_signals):\n", + " # conversion dB to dBC of the all third octave values.\n", + " dBC = spectrum2dBC(np.array(spectrum_all_signals_dB[:,i]), freq)\n", + " # For each frequency band you perform the operation.\n", + " for j in range(num_bands):\n", + " # Save all values in dBC of the third octave in another array.\n", + " spectrum_all_signals_dBC[j][i] = dBC[j]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally with the dBC values, the averaging of levels between the .wav fragments is performed to build the spectrum. Returns the spectrum in Thirds of Octave in dBC." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Third party imports\n", + "import math\n", + "\n", + "# Creating a list of zeros of the size of the frequency bands (to keep the spectrum_3oct_dBC values).\n", + "spectrum_3oct_dBC = np.zeros(num_bands)\n", + "# For each frequency band you perform the operation.\n", + "for i in range(num_bands): \n", + " sum = 0\n", + " # Performs the summation with all the values of the frequency band in the different signals.\n", + " for j in range(num_signals):\n", + " # Operation: summation(10^(level(dbC)[i]/10))\n", + " sum = sum + 10.0**(spectrum_all_signals_dBC[i][j]/10.0)\n", + " # Keep the spectrum_3oct_dBC value in the box corresponding to the frequency band from which the calculation is being made.\n", + " # Operation: 10 x log(base 10)[1/number of samples x sum]\n", + " spectrum_3oct_dBC[i] = 10.0 * math.log(((1/num_signals)*sum),10) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Returns spectrum_3oct_dBC, which is an array with as many values as there are frequency bands being operated. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Import useful packages\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"spectrum_3oct_dBC: \")\n", + "print(spectrum_3oct_dBC)\n", + "\n", + "print(\"Freq: \")\n", + "print(freq)\n", + "\n", + "#x_freq = ['25', '31.5', '40', '50', '63', '80', '100', '125', '160', '200', '250', '315',\n", + "# '400', '500', '630', '800', '1000', '1250', '1600', '2000', '2500', '3150', '4000', '5000', '6300', '8000',\n", + "# '10000', '12500']\n", + "x_freq = ['250', '315','400', '500', '630', '800', '1000', '1250', '1600', '2000', '2500', '3150', '4000',\n", + " '5000', '6300', '8000','10000', '12500', '16000', '20000']\n", + "y_values = spectrum_3oct_dBC\n", + "\n", + "# The figure is created\n", + "fig = plt.figure ()\n", + "# The object inside the figure is created\n", + "ax = fig.add_subplot (1, 1, 1)\n", + "\n", + "# Legend on the y axis\n", + "plt.ylabel ('Level dBA')\n", + "# Legend on the x axis\n", + "plt.xlabel ('Frequency Hz')\n", + "# Graphic Title\n", + "plt.title ('spectrum_3oct_dBC result in Thirds of Octave')\n", + "\n", + "# Bar graph is created\n", + "ax.bar (x_freq, y_values, color = \"C0\")\n", + "# Rotation of the x axis data\n", + "ax.set_xticklabels (x_freq, rotation = 75, fontsize = 9)\n", + "# Show the graph \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Max_level\n", + "The function returns the value of the maximum level. This function has two ways to calculate:\n", + " \n", + " - 1. max_level_3oct: for the maximum value of each frequency band.\n", + " - 2. max_level: for the maximum value of the time samples.\n", + " \n", + "##### max_level_3oct\n", + "Return the maximum value of the frequency bands you choose. Each one is calculated with the levels (dB) of its band in the different samples. This function chooses the maximum value with the help of the function max(), then they are stored in an empty array. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Local imports\n", + "from mosqito.utils.conversion import amp2db\n", + "\n", + "# We initialize the center frequencies of the third octaves with the first signal.\n", + "freq = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[1]\n", + "# We initialize the number of frequency bands.\n", + "num_bands = freq.shape[0]\n", + "\n", + "# Creating a list of zeros of the size of the frequency bands (to keep the maximum level values).\n", + "max_level_3oct = np.zeros(num_bands)\n", + "# Empty array to store the values in dB of the third octave whose maximum value is going to be calculated.\n", + "band_value_all_signals = np.zeros(num_signals)\n", + "# For each frequency band you perform the operation.\n", + "for i in range(num_bands):\n", + " # Performs the conversion to dB with all the values of the frequency band in the different signals.\n", + " for j in range(num_signals): \n", + " # Conversion Pa to dB.\n", + " dB = amp2db(np.array(spectrum_all_signals_Pa[i][j]))\n", + " # Save all values in dB of the third octave in another array.\n", + " band_value_all_signals[j] = dB\n", + " # Calculate and keep the maximum value found in the array. That value will be the maximum of the third of an octave.\n", + " max_level_3oct[i] = max(band_value_all_signals)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Returns max_level_3oct, which is an array with as many values as there are frequency bands being operated." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max_level_3oct: \n", + "[63.8992491 64.04536684 63.77114855 63.84416146 63.98343947 69.63145363\n", + " 89.02970598 69.65634143 63.98675717 64.54542347 65.39493741 66.41737014\n", + " 67.43603232 68.39139237 69.44300504 70.39115814 71.35822928 72.37940142\n", + " 73.35470088 74.35344573]\n", + "Freq: \n", + "[ 250. 315. 400. 500. 630. 800. 1000. 1250. 1600. 2000.\n", + " 2500. 3150. 4000. 5000. 6300. 8000. 10000. 12500. 16000. 20000.]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\hp\\AppData\\Local\\Temp\\ipykernel_3248\\2071398757.py:32: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " ax.set_xticklabels (x_freq, rotation = 75, fontsize = 9)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Import useful packages\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"Max_level_3oct: \")\n", + "print(max_level_3oct)\n", + "\n", + "print(\"Freq: \")\n", + "print(freq)\n", + "\n", + "#x_freq = ['25', '31.5', '40', '50', '63', '80', '100', '125', '160', '200', '250', '315',\n", + "# '400', '500', '630', '800', '1000', '1250', '1600', '2000', '2500', '3150', '4000', '5000', '6300', '8000',\n", + "# '10000', '12500']\n", + "x_freq = ['250', '315','400', '500', '630', '800', '1000', '1250', '1600', '2000', '2500', '3150', '4000',\n", + " '5000', '6300', '8000','10000', '12500', '16000', '20000']\n", + "y_values = max_level_3oct\n", + "\n", + "# The figure is created\n", + "fig = plt.figure ()\n", + "# The object inside the figure is created\n", + "ax = fig.add_subplot (1, 1, 1)\n", + "\n", + "# Legend on the y axis\n", + "plt.ylabel ('Level dB')\n", + "# Legend on the x axis\n", + "plt.xlabel ('Frequency Hz')\n", + "# Graphic Title\n", + "plt.title ('Spectrum Third Octave Band of three signals (Pink noise 60 dB)')\n", + "\n", + "# Bar graph is created\n", + "ax.bar (x_freq, y_values, color = \"C0\")\n", + "# Rotation of the x axis data\n", + "ax.set_xticklabels (x_freq, rotation = 75, fontsize = 9)\n", + "# Show the graph \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### max_level\n", + "Return the maximum value of the series of levels (dB) collected over time (samples). Searches all samples and returns the highest level with the help of the max() function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Local imports\n", + "from mosqito.utils.conversion import amp2db\n", + "\n", + "# Empty array to store the values in dB of the signal.\n", + "dB_values = np.zeros(signal.shape[0])\n", + "# Performs the conversion to dB with all the values of the signal.\n", + "for i in range(signal.shape[0]):\n", + " #If the value is negative value.\n", + " if signal[i] <= 0:\n", + " # we convert it to positive.\n", + " signal[i] = np.sqrt(np.mean(signal[i] ** 2))\n", + " # Conversion Pa to dB.\n", + " dB = amp2db(np.array(signal[i]))\n", + " # Save all values in dB of the third octave in another array.\n", + " dB_values[i] = dB\n", + "# Save the maximum level.\n", + "max_level = np.array(max(dB_values))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Returns max_level, which is one value representative of the samples." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max_level:\n", + "92.10419935517434\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Import useful packages\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"max_level:\")\n", + "print(max_level)\n", + "\n", + "# Legend on the y axis\n", + "plt.ylabel ('Level dB')\n", + "# Legend on the x axis\n", + "plt.xlabel ('Time samples')\n", + "# Graphic Title\n", + "plt.title ('Maximun of the temporary samples (Pink noise)')\n", + "\n", + "# Plot the signal with values in dB\n", + "plt.plot(dB_values)\n", + "# Plot the minimum value of the levels.\n", + "plt.axhline(y = max_level, color = 'r', linestyle = '-')\n", + "#show the graph\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Min_level\n", + "The function returns the value of the minimum level. This function has two ways to calculate:\n", + " \n", + " - 1. min_level_3oct: for the minimum value of each frequency band.\n", + " - 2. min_level: for the minimum value of the time samples.\n", + " \n", + "##### min_level_3oct\n", + "Return the minimum value of the frequency bands you choose. Each one is calculated with the levels (dB) of its band in the different samples. This function chooses the minimum value with the help of the function min(), then they are stored in an empty array. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Local imports\n", + "from mosqito.utils.conversion import amp2db\n", + "\n", + "# We initialize the center frequencies of the third octaves with the first signal.\n", + "freq = noct_spectrum(data_all_signals[0],fs,f_min,f_max)[1]\n", + "# We initialize the number of frequency bands.\n", + "num_bands = freq.shape[0]\n", + "\n", + "# Creating a list of zeros of the size of the frequency bands (to keep the minimum level values).\n", + "min_level_3oct = np.zeros(num_bands)\n", + "# Empty array to store the values in dB of the third octave whose minimum value is going to be calculated.\n", + "band_value_all_signals = np.zeros(num_signals)\n", + "# For each frequency band you perform the operation.\n", + "for i in range(num_bands):\n", + " # Performs the conversion to dB with all the values of the frequency band in the different signals.\n", + " for j in range(num_signals): \n", + " # Conversion Pa to dB.\n", + " dB = amp2db(np.array(spectrum_all_signals_Pa[i][j]))\n", + " # Save all values in dB of the third octave in another array.\n", + " band_value_all_signals[j] = dB\n", + " # Calculate and keep the maximum value found in the array. That value will be the maximum of the third of an octave.\n", + " min_level_3oct[i] = min(band_value_all_signals)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Returns min_level_3oct, which is an array with as many values as there are frequency bands being operated." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Import useful packages\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"Min_level_3oct: \")\n", + "print(min_level_3oct)\n", + "\n", + "print(\"Freq: \")\n", + "print(freq)\n", + "\n", + "#x_freq = ['25', '31.5', '40', '50', '63', '80', '100', '125', '160', '200', '250', '315',\n", + "# '400', '500', '630', '800', '1000', '1250', '1600', '2000', '2500', '3150', '4000', '5000', '6300', '8000',\n", + "# '10000', '12500']\n", + "x_freq = ['250', '315','400', '500', '630', '800', '1000', '1250', '1600', '2000', '2500', '3150', '4000',\n", + " '5000', '6300', '8000','10000', '12500', '16000', '20000']\n", + "y_values = min_level_3oct\n", + "\n", + "# The figure is created\n", + "fig = plt.figure ()\n", + "# The object inside the figure is created\n", + "ax = fig.add_subplot (1, 1, 1)\n", + "\n", + "# Legend on the y axis\n", + "plt.ylabel ('Level dB')\n", + "# Legend on the x axis\n", + "plt.xlabel ('Frequency Hz')\n", + "# Graphic Title\n", + "plt.title ('Spectrum Third Octave Band of three signals (Pink noise 60 dB)')\n", + "\n", + "# Bar graph is created\n", + "ax.bar (x_freq, y_values, color = \"C0\")\n", + "# Rotation of the x axis data\n", + "ax.set_xticklabels (x_freq, rotation = 75, fontsize = 9)\n", + "# Show the graph \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### min_level\n", + "Return the minimum value of the series of levels (dB) collected over time (samples). Searches all samples and returns the lowest level with the help of the min() function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Local imports\n", + "from mosqito.utils.conversion import amp2db\n", + "\n", + "# Empty array to store the values in dB of the signal.\n", + "dB_values = np.zeros(signal.shape[0])\n", + "# Performs the conversion to dB with all the values of the signal.\n", + "for i in range(signal.shape[0]):\n", + " #If the value is negative value.\n", + " if signal[i] <= 0:\n", + " # we convert it to positive.\n", + " signal[i] = np.sqrt(np.mean(signal[i] ** 2))\n", + " # Conversion Pa to dB.\n", + " dB = amp2db(np.array(signal[i]))\n", + " # Save all values in dB of the third octave in another array.\n", + " dB_values[i] = dB\n", + "# Save the minimum level.\n", + "min_level = np.array(min(dB_values))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Returns min_level, which is one value representative of the samples." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Import useful packages\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"min_level:\")\n", + "print(min_level)\n", + "\n", + "# Legend on the y axis\n", + "plt.ylabel ('Level dB')\n", + "# Legend on the x axis\n", + "plt.xlabel ('Time samples')\n", + "# Graphic Title\n", + "plt.title ('Minimun of the temporary samples (Pink noise)')\n", + "\n", + "# Plot the signal with values in dB\n", + "plt.plot(dB_values)\n", + "# Plot the minimum value of the levels.\n", + "plt.axhline(y = min_level, color = 'r', linestyle = '-')\n", + "#show the graph\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### LN(Percentile)\n", + "This function is only available for calculation with temporary samples.\n", + "\n", + "Return the percentile value of the series of levels (dB) collected over time (samples). Calculate the percentile you want to study from a series of levels (dB) collected over time (samples) with the help of the numpy.percentile() function. \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Local imports\n", + "from mosqito.utils.conversion import amp2db\n", + "\n", + "# Empty array to store the values in dB of the signal.\n", + "dB_values = np.zeros(signal.shape[0])\n", + "# Performs the conversion to dB with all the values of the signal.\n", + "for i in range(signal.shape[0]):\n", + " #If the value is negative value.\n", + " if signal[i] <= 0:\n", + " # we convert it to positive.\n", + " signal[i] = np.sqrt(np.mean(signal[i] ** 2))\n", + " # Conversion Pa to dB.\n", + " dB = amp2db(np.array(signal[i]))\n", + " # Save all values in dB of the third octave in another array.\n", + " dB_values[i] = dB\n", + "print('percentiles using interpolation = ', \"linear\")\n", + "# Calculate the percentiles with the values. \"q\" of np.percentile = 100 - N (N of LN).\n", + "L90 = np.percentile(dB_values, 10,interpolation='linear') \n", + "L50 = np.percentile(dB_values, 50,interpolation='linear') \n", + "L25 = np.percentile(dB_values, 75,interpolation='linear')\n", + "# Save the calculated percentile values.\n", + "percentiles = np.array([L90,L50,L25])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Returns percentiles, which is an array with all the percentiles that have been calculated." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Import useful packages\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"The values of L90, L50 and L25 of the temporary signal samples\")\n", + "print(percentiles)\n", + "\n", + "# Legend on the y axis\n", + "plt.ylabel ('Level dB')\n", + "# Legend on the x axis\n", + "plt.xlabel ('Time samples')\n", + "# Graphic Title\n", + "plt.title ('Percentiles of the temporary samples (Pink noise)')\n", + "\n", + "# Plot the signal with values in dB\n", + "plt.plot(dB_values)\n", + "# Plot the L90 value of the levels.\n", + "print(\"L90 is displayed in red\")\n", + "plt.axhline(y = L90, color = 'r', linestyle = '-')\n", + "# Plot the L50 value of the levels.\n", + "print(\"L50 is displayed in green\")\n", + "plt.axhline(y = L50, color = 'g', linestyle = '-')\n", + "# Plot the L90 value of the levels.\n", + "print(\"L25 is displayed in yelow\")\n", + "plt.axhline(y = L25, color = 'y', linestyle = '-')\n", + "#show the graph\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "base_numbering": "1", + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": true, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": true, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/wiki/img/coming-soon.png b/wiki/img/coming-soon.png new file mode 100644 index 00000000..13e4c429 Binary files /dev/null and b/wiki/img/coming-soon.png differ diff --git a/wiki/img/logo.png b/wiki/img/logo.png new file mode 100644 index 00000000..b48d8da8 Binary files /dev/null and b/wiki/img/logo.png differ diff --git a/wiki/img/problems_code/img_problems_code_1.png b/wiki/img/problems_code/img_problems_code_1.png new file mode 100644 index 00000000..8b76f7c1 Binary files /dev/null and b/wiki/img/problems_code/img_problems_code_1.png differ diff --git a/wiki/img/problems_python/img_problems_python_1.png b/wiki/img/problems_python/img_problems_python_1.png new file mode 100644 index 00000000..94b2012f Binary files /dev/null and b/wiki/img/problems_python/img_problems_python_1.png differ diff --git a/wiki/img/problems_python/img_problems_python_10.png b/wiki/img/problems_python/img_problems_python_10.png new file mode 100644 index 00000000..71895a73 Binary files /dev/null and b/wiki/img/problems_python/img_problems_python_10.png differ diff --git a/wiki/img/problems_python/img_problems_python_11.png b/wiki/img/problems_python/img_problems_python_11.png new file mode 100644 index 00000000..22b69cd9 Binary files /dev/null and b/wiki/img/problems_python/img_problems_python_11.png differ diff --git a/wiki/img/problems_python/img_problems_python_12.png b/wiki/img/problems_python/img_problems_python_12.png new file mode 100644 index 00000000..767cc7f1 Binary files /dev/null and b/wiki/img/problems_python/img_problems_python_12.png differ diff --git a/wiki/img/problems_python/img_problems_python_2.png b/wiki/img/problems_python/img_problems_python_2.png new file mode 100644 index 00000000..cd735619 Binary files /dev/null and b/wiki/img/problems_python/img_problems_python_2.png differ diff --git a/wiki/img/problems_python/img_problems_python_3.png b/wiki/img/problems_python/img_problems_python_3.png new file mode 100644 index 00000000..737ede0c Binary files /dev/null and b/wiki/img/problems_python/img_problems_python_3.png differ diff --git a/wiki/img/problems_python/img_problems_python_4.png b/wiki/img/problems_python/img_problems_python_4.png new file mode 100644 index 00000000..8ad11109 Binary files /dev/null and b/wiki/img/problems_python/img_problems_python_4.png differ diff --git a/wiki/img/problems_python/img_problems_python_5.png b/wiki/img/problems_python/img_problems_python_5.png new file mode 100644 index 00000000..1ecabd28 Binary files /dev/null and b/wiki/img/problems_python/img_problems_python_5.png differ diff --git a/wiki/img/problems_python/img_problems_python_6.png b/wiki/img/problems_python/img_problems_python_6.png new file mode 100644 index 00000000..4ea22263 Binary files /dev/null and b/wiki/img/problems_python/img_problems_python_6.png differ diff --git a/wiki/img/problems_python/img_problems_python_7.png b/wiki/img/problems_python/img_problems_python_7.png new file mode 100644 index 00000000..b66d2c49 Binary files /dev/null and b/wiki/img/problems_python/img_problems_python_7.png differ diff --git a/wiki/img/problems_python/img_problems_python_8.png b/wiki/img/problems_python/img_problems_python_8.png new file mode 100644 index 00000000..542d722f Binary files /dev/null and b/wiki/img/problems_python/img_problems_python_8.png differ diff --git a/wiki/img/problems_python/img_problems_python_9.png b/wiki/img/problems_python/img_problems_python_9.png new file mode 100644 index 00000000..9465e424 Binary files /dev/null and b/wiki/img/problems_python/img_problems_python_9.png differ diff --git a/wiki/img/problems_respository/img_problems_respository_1.png b/wiki/img/problems_respository/img_problems_respository_1.png new file mode 100644 index 00000000..7f459b11 Binary files /dev/null and b/wiki/img/problems_respository/img_problems_respository_1.png differ