HearingTest.py

import time
import numpy as np
import random
from SoundLibrary import SoundLibrary
from typing import List
# from HearingTestGUI import HearingMplCanvas

class SoundRecord:
    def __init__(self, freq, volume, time):
        self.freq = freq
        self.volume = volume
        self.time = time
        self.heard = None


class HearingTest:
    upper_lim = 1
    lower_lim = 0
    n_blocks = 20
    max_response_time = 1  # in seconds

    @staticmethod
    def get_block_size():
        return (HearingTest.upper_lim - HearingTest.lower_lim) / HearingTest.n_blocks

    def __init__(self, library: SoundLibrary, canvas):
        self.library = library
        self.lower_bounds = np.full_like(self.freqs, fill_value=self.lower_lim, dtype=float)
        self.upper_bounds = np.full_like(self.freqs, fill_value=self.upper_lim, dtype=float)
        self.false_presses = 0
        self.sounds = []
        self.canvas = canvas

    @property
    def freqs(self):
        return self.library.freqs

    def handle_key_press(self, _time):
        sound = self.sounds[-1]
        if not sound.heard and (_time - sound.time <= self.max_response_time):
            sound.heard = True
            if self.lower_bounds[self.freqs == sound.freq] < sound.volume:
                self.set_lower_bound(sound.freq, sound.volume)
        else:
            self.false_presses += 1
        self.check_for_not_heard(_time)
        return

    def play_next_sound(self):
        # TODO select tone based on results
        volume = random.random()
        freq = random.choice(self.freqs)
        self.library.play(freq, volume)
        played_time = time.time()

        next_sleep_time = random.uniform(self.max_response_time*1.2, self.max_response_time*3)

        self.sounds.append(SoundRecord(freq, volume, played_time))
        test_finished = False

        self.check_for_not_heard(played_time)
        return test_finished, freq, volume, played_time, next_sleep_time

    def check_for_not_heard(self, event_time):
        for sound in reversed(self.sounds):
            delay = event_time - sound.time
            # print(delay)
            if sound.heard is not None:
                break
            elif delay > self.max_response_time:
                sound.heard = False
                if self.upper_bounds[self.freqs == sound.freq] > sound.volume:
                    self.set_upper_bound(sound.freq, sound.volume)

    def set_lower_bound(self, freq, volume):
        self.lower_bounds[self.freqs == freq] = volume
        self.canvas.update_result(self)

    def set_upper_bound(self, freq, volume):
        self.upper_bounds[self.freqs == freq] = volume
        self.canvas.update_result(self)