def validation_loudness_zwicker_wav(signal): """Test function for the script loudness_zwicker_stationary Test function for the script loudness_zwicker_stationary with .wav file as input. The input file is provided by ISO 532-1 annex B3, the compliance is assessed according to section 5.1 of the standard. One .png compliance plot is generated. Parameters ---------- None Outputs ------- None """ # Load signal and compute third octave band spectrum sig, fs = load(True, signal["data_file"], calib=2 * 2**0.5) # Compute Loudness loudness = comp_loudness(True, sig, fs) # Check ISO 532-1 compliance assert check_compliance(loudness, signal)
def validation_sharpness(noise): """Test function for the script sharpness_din Test function for the script sharpness_din with .wav filesas input. The input files are provided by DIN 45692_2009E The compliance is assessed according to chapter 6 of the standard. One .png compliance plot is generated. Parameters ---------- None Outputs ------- None """ sharpness = np.zeros((len(noise))) reference = np.zeros((len(noise))) for i in range(len(noise)): # Load signal sig, fs = load(True, noise[i]["data_file"], calib=1) # Compute sharpness S = comp_sharpness(True, sig, fs, method='din') sharpness[i] = S['values'] # Load reference value reference[i] = noise[i]['S'] noise_type = noise[0]["type"] check_compliance(sharpness, reference, noise_type)
def test_sharpness(): """Test function for the sharpness calculation of an audio signal Test function for the function "comp_roughness" with 'din' method. The input signals come from DIN 45692_2009E. The compliance is assessed according to chapter 6 of the standard. One .png compliance plot is generated. Parameters ---------- None Outputs ------- None """ # Input signal from DIN 45692_2009E signal = { "data_file": r"mosqito\tests\sharpness\Standard\1KHZ60DB.wav", "S": 1 } # Load signal sig, fs = load(True, signal["data_file"], calib=1) # Compute sharpness sharpness = comp_sharpness(True, sig, fs, method="din") S = sharpness["values"] assert check_compliance(S, signal)
def validation_loudness_zwicker_time(signal): """Test function for the script loudness_zwicker_time Test function for the script comp_loudness with time-varying .wav file as input. The input file is provided by ISO 532-1 annex B4 and B5, the compliance is assessed according to section 6.1 of the standard. One .png compliance plot is generated. Parameters ---------- signal: dict { "data_file": <Path to reference input signal>, "N_file": <Path to reference calculated loudness versus time> "N_specif_file": <Path to reference calculated specific loudness> "N_specif_bark": <Bark value of the reference calculation> } Outputs ------- None """ # Load signal and compute third octave band spectrum sig, fs = load(False, signal["data_file"], calib=2 * 2**0.5) # Compute Loudness loudness = comp_loudness(False, sig, fs, signal["field"]) # Check ISO 532-1 compliance assert check_compliance(loudness, signal)
def test_loudness_zwicker_wav(): """Test function for the script loudness_zwicker_stationary Test function for the script loudness_zwicker_stationary with .wav file as input. The input file is provided by ISO 532-1 annex B3, the compliance is assessed according to section 5.1 of the standard. One .png compliance plot is generated. Parameters ---------- None Outputs ------- None """ # Test signal as input for stationary loudness # (from ISO 532-1 annex B3) signal = { "data_file": "tests/input/Test signal 3 (1 kHz 60 dB).wav", "N": 4.019, "N_specif_file": "tests/input/test_signal_3.csv", } # Load signal and compute third octave band spectrum sig, fs = load(True, signal["data_file"], calib=2 * 2**0.5) # Compute Loudness loudness = comp_loudness(True, sig, fs) # Check ISO 532-1 compliance assert check_compliance(loudness, signal, "./tests/output/")
def import_signal(self, is_stationary, file, calib=1, mat_signal='', mat_fs=''): """ Method to load the signal from a .wav .mat or .uff file Parameters ---------- is_stationary : boolean TRUE if the signal is stationary, FALSE if it is time-varying file : string string path to the signal file calib : float calibration factor for the signal to be in [pa] mat_signal : string in case of a .mat file, name of the signal variable mat_fs : string in case of a .mat file, name of the sampling frequency variable Outputs ------- signal : numpy.array time signal values fs : integer sampling frequency """ self.is_stationary = is_stationary values, self.fs = load(self.is_stationary, file, calib, mat_signal, mat_fs) self.signal = Data1D(values=values, name="Audio signal", unit='Pa') self.time_axis = DataLinspace( initial=0, final=len(self.signal.values) / self.fs, step=1 / self.fs, )
def test_tnr(): """Test function for the prominence ratio calculation of an audio signal Validation function for the Audio_signal class "comp_tnr" method with signal array as input. The input signals are generated using audacity. Parameters ---------- None Outputs ------- None """ # Test signal as input for prominence ratio calculation # signals generated using audacity : white noise + tones at 200 and 2000 Hz # the first one is stationary, the second is time-varying signal = [] signal.append({ "is_stationary": True, "tones freq": [200, 2000], "data_file": r"tests\input\white_noise_442_1768_Hz_stationary.wav", }) signal.append({ "is_stationary": False, "data_file": r"tests\input\white_noise_442_1768_Hz_varying.wav", }) for i in range(len(signal)): # Load signal audio, fs = load(signal[i]["is_stationary"], signal[i]["data_file"]) # Compute tone-to-noise ratio tnr = comp_tnr(signal[i]["is_stationary"], audio, fs, prominence=True)
def test_loudness_zwicker_time(): """Test function for the script loudness_zwicker_time Test function for the script loudness_zwicker_time with .wav file as input. The input file is provided by ISO 532-1 annex B4 and B5, the compliance is assessed according to section 6.1 of the standard. One .png compliance plot is generated. Parameters ---------- None Outputs ------- None """ # Test signal as input for time-varying loudness # (from ISO 532-1 annex B4) signal = { "data_file": "tests/input/Test signal 6 (tone 250 Hz 30 dB - 80 dB).wav", "xls": "tests/input/Results and tests for synthetic signals (time varying loudness).xlsx", "tab": "Test signal 6", "N_specif_bark": 2.5, "field": "free", } # Load signal and compute third octave band spectrum sig, fs = load(False, signal["data_file"], calib=2 * 2**0.5) # Compute Loudness loudness = comp_loudness(False, sig, fs, signal["field"]) # Check ISO 532-1 compliance assert check_compliance(loudness, signal, "./tests/output/")
min frequency of the output spectrum fmax : float max frequency of the output spectrum n : int number of bands pr octave Outputs -------- spectrum : ndarray nth octave band spectrum of signal sig [Pa] freq : ndarray Corresponding nth octave bands center frequencies """ f_dict = getFrequencies(fmin, fmax, n) filters = designFilters(f_dict, fs, plot=False) spectrum = analyseData(filters, signal, f_dict, plot=False) freq = [nominal_center_freq(f, n) for f in f_dict["f"][:, 1]] return spectrum if __name__ == "__main__": signal, fs = load( True, "./validations/loudness_zwicker/data/ISO_532-1/Test signal 5 (pinknoise 60 dB).wav", calib=2 * 2**0.5, ) spectrum = comp_nth_spec(signal, fs)
def __init__(self, file, is_stationary=False, calib=1, mat_signal="", mat_fs=""): """Constructor of the class. Loads the signal from a .wav .mat or .uff file Parameters ---------- self : Audio object Object from the Audio class file : string string path to the signal file is_stationary : boolean TRUE if the signal is stationary, FALSE if it is time-varying calib : float calibration factor for the signal to be in [pa] mat_signal : string in case of a .mat file, name of the signal variable mat_fs : string in case of a .mat file, name of the sampling frequency variable """ # Import audio signal values, fs = load( is_stationary, file, calib=calib, mat_signal=mat_signal, mat_fs=mat_fs, ) # Create Data object for time axis time_axis = DataLinspace( name="time", unit="s", initial=0, final=(len(values) - 1) / fs, number=len(values), include_endpoint=True, ) # Create audio signal Data object and populate the object self.fs = fs self.is_stationary = is_stationary self.signal = DataTime( name="Audio signal", symbol="x", unit="Pa", normalizations={"ref": 2e-5}, axes=[time_axis], values=values, ) # Init physical metrics attributes self.third_spec = None self.level = None self.welch = None # Init physiological metrics attributes self.loudness_zwicker = None self.loudness_zwicker_specific = None self.sharpness = dict() self.roughness = dict() self.tonality = dict()