def signaldata_from_json(o, preferences):
'''
Converts the given dict to a SignalData if it is compatible.
:param o: the dict (from json).
:return: the SignalData (or an error)
'''
from model.signal import SingleChannelSignalData, BassManagedSignalData
if '_type' not in o:
raise ValueError(f"{o} is not SignalData")
elif o['_type'] == BassManagedSignalData.__name__:
channels = [signaldata_from_json(c, preferences) for c in o['channels']]
lpf_fs = float(o['bm']['lpf_fs'])
lpf_position = o['bm']['lpf_position']
offset = float(o['offset'])
bmsd = BassManagedSignalData(channels, lpf_fs, lpf_position, preferences, offset=offset)
bmsd.bm_headroom_type = o['bm']['headroom_type']
bmsd.clip_before = o['clip']['before']
bmsd.clip_after = o['clip']['after']
return bmsd
elif o['_type'] == SingleChannelSignalData.__name__ or o['_type'] == 'SignalData':
filt = o.get('filter', None)
if filt is not None:
filt = filter_from_json(filt)
data = o['data']
avg = xydata_from_json(data['avg'])
peak = xydata_from_json(data['peak'])
median = xydata_from_json(data['median']) if 'median' in data else None
xy_data = [avg, peak] if median is None else [avg, peak, median]
metadata = o.get('metadata', None)
offset = float(o.get('offset', 0.0))
signal = None
if metadata is not None:
try:
if os.path.isfile(metadata['src']):
from model.signal import readWav
signal = readWav(o['name'], preferences, input_file=metadata['src'], channel=metadata['channel'],
start=metadata['start'], end=metadata['end'], target_fs=o['fs'], offset=offset)
except:
logger.exception(f"Unable to load signal from {metadata['src']}")
if 'duration_seconds' in o:
signal_data = SingleChannelSignalData(o['name'], o['fs'], xy_data=xy_data, filter=filt,
duration_seconds=o.get('duration_seconds', None),
start_seconds=o.get('start_seconds', None),
signal=signal,
offset=offset)
elif 'duration_hhmmss' in o:
h, m, s = o['duration_hhmmss'].split(':')
duration_seconds = (int(h) * 3600) + int(m) * (60 + float(s))
h, m, s = o['start_hhmmss'].split(':')
start_seconds = (int(h) * 3600) + int(m) * (60 + float(s))
signal_data = SingleChannelSignalData(o['name'], o['fs'], xy_data=xy_data, filter=filt,
duration_seconds=duration_seconds,
start_seconds=start_seconds,
signal=signal,
offset=offset)
else:
signal_data = SingleChannelSignalData(o['name'], o['fs'], xy_data=xy_data, filter=filt, signal=signal,
offset=offset)
return signal_data
raise ValueError(f"{o._type} is an unknown signal type")
def get_curve_data(self, reference=None):
'''
:param reference: ignored as we don't expose a normalisation control in this chart.
:return: the peak and avg spectrum for the currently filtered signal (if any).
'''
if self.__active_signal is not None and self.__magnitude_model.is_visible(
):
sig = SingleChannelSignalData(signal=self.__active_signal.cut(
to_seconds(self.__start_time), to_seconds(self.__end_time)))
sig.reindex(self.__selector.currentIndex() - 1)
return sig.get_all_xy()
return []
def test_codec_signal():
fs = 1000
peak = LowShelf(fs, 30, 1, 10,
count=2).get_transfer_function().get_magnitude()
avg = LowShelf(fs, 30, 1, 10).get_transfer_function().get_magnitude()
median = LowShelf(fs, 30, 1, 10).get_transfer_function().get_magnitude()
filt = CompleteFilter()
filt.save(HighShelf(fs, 60, 1, 5, count=2))
data = SingleChannelSignalData('test',
fs,
xy_data=[avg, peak, median],
filter=filt,
duration_seconds=123456,
start_seconds=123,
offset=4.2)
output = json.dumps(signaldata_to_json(data))
assert output is not None
decoded = signaldata_from_json(json.loads(output), None)
assert decoded is not None
assert isinstance(decoded, SingleChannelSignalData)
assert decoded.name == data.name
assert decoded.fs == data.fs
assert decoded.filter is not None
assert type(decoded.filter) is type(data.filter)
assert decoded.filter.id != -1
assert decoded.filter.description == data.filter.description
assert decoded.filter.filters == data.filter.filters
assert decoded.current_unfiltered is not None
assert len(decoded.current_unfiltered) == 3
assert decoded.current_unfiltered == data.current_unfiltered
assert decoded.duration_hhmmss == data.duration_hhmmss
assert decoded.start_hhmmss == data.start_hhmmss
assert decoded.end_hhmmss == data.end_hhmmss
assert decoded.offset == data.offset
def __create_pulse(self, c, f):
from scipy.signal import unit_impulse
from model.signal import SingleChannelSignalData, Signal
signal = Signal(f"pulse_{c}",
unit_impulse(4 * HTP1_FS, 'mid'),
self.__preferences,
fs=HTP1_FS)
return SingleChannelSignalData(name=f"pulse_{c}",
filter=f,
signal=signal)