guitarsounds.parameters

  1class Parameter(object):
  2    """
  3    A class to store the individual sound parameters
  4    """
  5    def __init__(self, name, value, info):
  6        self.name = name
  7        self.value = value
  8        self.info = info
  9
 10
 11class ParameterSet(object):
 12    """
 13    A class to store multiple parameters as a set
 14    """
 15    def __init__(self, name, *parameters):
 16        self.name = name
 17        for parameter in parameters:
 18            setattr(self, parameter.name, parameter)
 19
 20    def info(self):
 21        print(self.name)
 22        parameters = [parameter for parameter in self.__dict__.values() if type(parameter) != str]
 23        for parameter in parameters:
 24            print('\t', parameter.name, ':', parameter.value)
 25
 26
 27class GlobalParameters(object):
 28    """
 29    A class to store the parameter sets and to be used to assign parameter values to the different functions
 30    """
 31
 32    def __init__(self, *parameter_sets):
 33        for parameter_set in parameter_sets:
 34            setattr(self, parameter_set.name, parameter_set)
 35
 36    def info(self):
 37        """
 38        Prints the name and values of every parameter
 39        """
 40        for parameter_set in self.__dict__.values():
 41            print(parameter_set.name)
 42            parameters = [parameter for parameter in parameter_set.__dict__.values() if type(parameter) != str]
 43            for parameter in parameters:
 44                print('\t', parameter.name, ':', parameter.value)
 45
 46    def more_info(self):
 47        """
 48        Prints the name, value and info string of every parameter
 49        """
 50        for parameter_set in self.__dict__.values():
 51            print(parameter_set.name)
 52            parameters = [parameter for parameter in parameter_set.__dict__.values() if type(parameter) != str]
 53            for parameter in parameters:
 54                info = '[' + parameter.info + ']'
 55                print('\t', parameter.name, ':', parameter.value, info)
 56
 57    def change(self, name, value):
 58        """
 59        Change the parameter with the name `name` from its current value to the specified value
 60        """
 61        for parameter_set in self.__dict__.values():
 62            parameters = [parameter for parameter in parameter_set.__dict__.values() if type(parameter) != str]
 63            for parameter in parameters:
 64                if parameter.name == name:
 65                    parameter.value = value
 66
 67
 68def sound_parameters():
 69    """
 70    Function returning the instance of the sound parameters
 71    """
 72    # General
 73    octave_fraction = Parameter('octave_fraction', 3, 'Fraction of the octave used for octave computations')
 74    fft_range = Parameter('fft_range', 2000, 'Maximum frequency in the Fourier transform plot')
 75    general = ParameterSet('general', octave_fraction, fft_range)
 76
 77    # Onset
 78    onset_delay = Parameter('onset_delay', 100, 'Delay before the onset (attack) in milliseconds to keep when trimming the signal')
 79    onset_time = Parameter('onset_time', 0.005, 'Time interval used to detect the onset in seconds')
 80    onset = ParameterSet('onset', onset_delay, onset_time)
 81
 82    # envelope
 83    frame_size = Parameter('frame_size', 301, 'Number of samples in the array used to compute a point of the envelope')
 84    hop_length = Parameter('hop_length', 200, 'Number of samples between envelope points')
 85    envelope = ParameterSet('envelope', frame_size, hop_length)
 86
 87    # Log envelope
 88    start_time = Parameter('start_time', 0.01, 'First point in the log scale envelope')
 89    min_window = Parameter('min_window', None, 'Minimum window size for the log envelope computed from start_time by '
 90                                               'default')
 91    max_window = Parameter('max_window', 2048, 'Maximum window size for the log envelope in samples')
 92    log_envelope = ParameterSet('log_envelope', start_time, min_window, max_window)
 93
 94    # Fundamental
 95    min_freq = Parameter('min_freq', 60, 'Minimum frequency for the fundamental finding algorithm (Hz)')
 96    max_freq = Parameter('max_freq', 2000, 'Maximum frequency for the fundamental finding algorithm (Hz)')
 97    frame_length = Parameter('frame_length', 1024, 'Frame length in samples to compute the fundamentals in the signal')
 98    fundamental = ParameterSet('fundamental', min_freq, max_freq, frame_length)
 99
100    # Frequency bins to divide the signal
101    bass = Parameter('bass', 100, 'Higher cutoff value for the bass bin (Hz), the lower value is zero')
102    mid = Parameter('mid', 700, 'Higher cutoff value for the mid bin (Hz)')
103    highmid = Parameter('highmid', 2000, 'Higher cutoff value for the highmid bin (Hz)')
104    uppermid = Parameter('uppermid', 4000, 'Higher cutoff value for the uppermid bin (Hz)')
105    presence = Parameter('presence', 6000, 'Higher cutoff value for the presence bin (Hz),'
106                                           ' the brilliance bin is above this frequency')
107    bins = ParameterSet('bins', bass, mid, highmid, uppermid, presence)
108
109    # Damping
110    lower_threshold = Parameter('lower_threshold', 0.05, 'lower amplitude threshold for the time damping analysis')
111    damping = ParameterSet('damping', lower_threshold)
112    
113    # Default signal trim times
114    E = Parameter('E2', 4.0, 'Default trim time for the E2 note')
115    A = Parameter('A2', 3.5, 'Default trim time for the A2 note') 
116    D = Parameter('D3', 3.5, 'Default trim time for the D3 note')
117    G = Parameter('G3', 3.0, 'Default trim time for the G3 note') 
118    B = Parameter('B3', 3.0, 'Default trim time for the B3 note')
119    e = Parameter('E4', 2.5, 'Default trim time for the E4 note')
120    trim_times = ParameterSet('trim', E, A, D, G, B, e)
121
122    SoundParameters = GlobalParameters(general, onset, envelope, log_envelope, fundamental, bins, damping, trim_times)
123
124    return SoundParameters
class Parameter:
 3class Parameter(object):
 4    """
 5    A class to store the individual sound parameters
 6    """
 7    def __init__(self, name, value, info):
 8        self.name = name
 9        self.value = value
10        self.info = info

A class to store the individual sound parameters

Parameter(name, value, info)
 7    def __init__(self, name, value, info):
 8        self.name = name
 9        self.value = value
10        self.info = info
class ParameterSet:
13class ParameterSet(object):
14    """
15    A class to store multiple parameters as a set
16    """
17    def __init__(self, name, *parameters):
18        self.name = name
19        for parameter in parameters:
20            setattr(self, parameter.name, parameter)
21
22    def info(self):
23        print(self.name)
24        parameters = [parameter for parameter in self.__dict__.values() if type(parameter) != str]
25        for parameter in parameters:
26            print('\t', parameter.name, ':', parameter.value)

A class to store multiple parameters as a set

ParameterSet(name, *parameters)
17    def __init__(self, name, *parameters):
18        self.name = name
19        for parameter in parameters:
20            setattr(self, parameter.name, parameter)
def info(self):
22    def info(self):
23        print(self.name)
24        parameters = [parameter for parameter in self.__dict__.values() if type(parameter) != str]
25        for parameter in parameters:
26            print('\t', parameter.name, ':', parameter.value)
class GlobalParameters:
29class GlobalParameters(object):
30    """
31    A class to store the parameter sets and to be used to assign parameter values to the different functions
32    """
33
34    def __init__(self, *parameter_sets):
35        for parameter_set in parameter_sets:
36            setattr(self, parameter_set.name, parameter_set)
37
38    def info(self):
39        """
40        Prints the name and values of every parameter
41        """
42        for parameter_set in self.__dict__.values():
43            print(parameter_set.name)
44            parameters = [parameter for parameter in parameter_set.__dict__.values() if type(parameter) != str]
45            for parameter in parameters:
46                print('\t', parameter.name, ':', parameter.value)
47
48    def more_info(self):
49        """
50        Prints the name, value and info string of every parameter
51        """
52        for parameter_set in self.__dict__.values():
53            print(parameter_set.name)
54            parameters = [parameter for parameter in parameter_set.__dict__.values() if type(parameter) != str]
55            for parameter in parameters:
56                info = '[' + parameter.info + ']'
57                print('\t', parameter.name, ':', parameter.value, info)
58
59    def change(self, name, value):
60        """
61        Change the parameter with the name `name` from its current value to the specified value
62        """
63        for parameter_set in self.__dict__.values():
64            parameters = [parameter for parameter in parameter_set.__dict__.values() if type(parameter) != str]
65            for parameter in parameters:
66                if parameter.name == name:
67                    parameter.value = value

A class to store the parameter sets and to be used to assign parameter values to the different functions

GlobalParameters(*parameter_sets)
34    def __init__(self, *parameter_sets):
35        for parameter_set in parameter_sets:
36            setattr(self, parameter_set.name, parameter_set)
def info(self):
38    def info(self):
39        """
40        Prints the name and values of every parameter
41        """
42        for parameter_set in self.__dict__.values():
43            print(parameter_set.name)
44            parameters = [parameter for parameter in parameter_set.__dict__.values() if type(parameter) != str]
45            for parameter in parameters:
46                print('\t', parameter.name, ':', parameter.value)

Prints the name and values of every parameter

def more_info(self):
48    def more_info(self):
49        """
50        Prints the name, value and info string of every parameter
51        """
52        for parameter_set in self.__dict__.values():
53            print(parameter_set.name)
54            parameters = [parameter for parameter in parameter_set.__dict__.values() if type(parameter) != str]
55            for parameter in parameters:
56                info = '[' + parameter.info + ']'
57                print('\t', parameter.name, ':', parameter.value, info)

Prints the name, value and info string of every parameter

def change(self, name, value):
59    def change(self, name, value):
60        """
61        Change the parameter with the name `name` from its current value to the specified value
62        """
63        for parameter_set in self.__dict__.values():
64            parameters = [parameter for parameter in parameter_set.__dict__.values() if type(parameter) != str]
65            for parameter in parameters:
66                if parameter.name == name:
67                    parameter.value = value

Change the parameter with the name name from its current value to the specified value

def sound_parameters():
 70def sound_parameters():
 71    """
 72    Function returning the instance of the sound parameters
 73    """
 74    # General
 75    octave_fraction = Parameter('octave_fraction', 3, 'Fraction of the octave used for octave computations')
 76    fft_range = Parameter('fft_range', 2000, 'Maximum frequency in the Fourier transform plot')
 77    general = ParameterSet('general', octave_fraction, fft_range)
 78
 79    # Onset
 80    onset_delay = Parameter('onset_delay', 100, 'Delay before the onset (attack) in milliseconds to keep when trimming the signal')
 81    onset_time = Parameter('onset_time', 0.005, 'Time interval used to detect the onset in seconds')
 82    onset = ParameterSet('onset', onset_delay, onset_time)
 83
 84    # envelope
 85    frame_size = Parameter('frame_size', 301, 'Number of samples in the array used to compute a point of the envelope')
 86    hop_length = Parameter('hop_length', 200, 'Number of samples between envelope points')
 87    envelope = ParameterSet('envelope', frame_size, hop_length)
 88
 89    # Log envelope
 90    start_time = Parameter('start_time', 0.01, 'First point in the log scale envelope')
 91    min_window = Parameter('min_window', None, 'Minimum window size for the log envelope computed from start_time by '
 92                                               'default')
 93    max_window = Parameter('max_window', 2048, 'Maximum window size for the log envelope in samples')
 94    log_envelope = ParameterSet('log_envelope', start_time, min_window, max_window)
 95
 96    # Fundamental
 97    min_freq = Parameter('min_freq', 60, 'Minimum frequency for the fundamental finding algorithm (Hz)')
 98    max_freq = Parameter('max_freq', 2000, 'Maximum frequency for the fundamental finding algorithm (Hz)')
 99    frame_length = Parameter('frame_length', 1024, 'Frame length in samples to compute the fundamentals in the signal')
100    fundamental = ParameterSet('fundamental', min_freq, max_freq, frame_length)
101
102    # Frequency bins to divide the signal
103    bass = Parameter('bass', 100, 'Higher cutoff value for the bass bin (Hz), the lower value is zero')
104    mid = Parameter('mid', 700, 'Higher cutoff value for the mid bin (Hz)')
105    highmid = Parameter('highmid', 2000, 'Higher cutoff value for the highmid bin (Hz)')
106    uppermid = Parameter('uppermid', 4000, 'Higher cutoff value for the uppermid bin (Hz)')
107    presence = Parameter('presence', 6000, 'Higher cutoff value for the presence bin (Hz),'
108                                           ' the brilliance bin is above this frequency')
109    bins = ParameterSet('bins', bass, mid, highmid, uppermid, presence)
110
111    # Damping
112    lower_threshold = Parameter('lower_threshold', 0.05, 'lower amplitude threshold for the time damping analysis')
113    damping = ParameterSet('damping', lower_threshold)
114    
115    # Default signal trim times
116    E = Parameter('E2', 4.0, 'Default trim time for the E2 note')
117    A = Parameter('A2', 3.5, 'Default trim time for the A2 note') 
118    D = Parameter('D3', 3.5, 'Default trim time for the D3 note')
119    G = Parameter('G3', 3.0, 'Default trim time for the G3 note') 
120    B = Parameter('B3', 3.0, 'Default trim time for the B3 note')
121    e = Parameter('E4', 2.5, 'Default trim time for the E4 note')
122    trim_times = ParameterSet('trim', E, A, D, G, B, e)
123
124    SoundParameters = GlobalParameters(general, onset, envelope, log_envelope, fundamental, bins, damping, trim_times)
125
126    return SoundParameters

Function returning the instance of the sound parameters