asmu 0.0.1__py3-none-any.whl

asmu/__init__.py

@@ -0,0 +1,9 @@
+from .analysis import get_corrs_sampleshifts, calSPL
+from .generator import SincBurst, Sine, WhiteNoise, SineBurst, Chirp
+from .inout import Input, Output
+from .interface import Interface
+from .recording import Recording
+from .setup import Setup
+#NOT IMPLEMENTED from .view import TimeView, Corrview
+
+__all__ = ["get_corrs_sampleshifts", "calSPL", "SincBurst", "Sine", "WhiteNoise", "SineBurst", "Chirp", "generator", "Input", "Output", "Interface", "Recording", "Setup"]

asmu/analysis.py

@@ -0,0 +1,68 @@
+import numpy as np
+import scipy as sp
+import queue
+
+class Analyzer():
+    def __init__(self, chunk, queuesize):
+        self._chunk = chunk
+
+        self._w = np.hanning(chunk)
+        self._q = queue.Queue(queuesize)
+
+    def reset(self):
+        # process full queue
+        while not self._q.empty():
+            self.process_queue()
+
+    def put_queue(self, data):
+        self._q.put(data.copy())
+
+    def process_queue(self):
+        pass
+
+    def _get_fft(self) -> np.ndarray:
+        return np.fft.rfft(self._q.get()*self._w, axis=0, norm="forward")*2/np.mean(self._w)
+
+class calSPL(Analyzer):
+    def __init__(self, chunk, queuesize: int=10):
+        self._uks = []
+        self._ks = []
+        super().__init__(chunk, queuesize)
+
+    def process_queue(self):
+        ukm = self._get_fft()
+
+        kmax = np.argmax(np.abs(ukm))
+        self._uks.append(np.abs(ukm[kmax]))
+        self._ks.append(kmax)
+
+    def get_cSPL(self, spl):
+        self.reset()
+
+        p0 = 2e-5                           # [Pa]Rms
+        p = p0 * 10 ** (spl / 20)           # [Pa]Rms
+        pcal = p * np.sqrt(2)               # [Pa]
+
+        return pcal/np.mean(self._uks[2:]) # dont use the first three measurements
+
+    def get_kSPL(self):
+        return round(np.mean(self._ks))
+    
+def get_corrs_sampleshifts(indata: np.ndarray, refdata: np.ndarray, burstLength: int) -> tuple[np.ndarray, np.ndarray]:
+    corrs = []
+    sampleshifts = []
+    n = int(np.size(refdata))
+    for cidx in range(np.ma.size(indata, axis=1)):
+        v = indata[:, cidx]
+        corr = sp.signal.correlate(v, refdata)
+        corr /= np.max(corr)
+        peaks, _ = sp.signal.find_peaks(corr, prominence=0.8, distance=burstLength, height=0.5)
+
+        # shift correlation correctly
+        corrs.append(corr[n-1:])
+        sampleshifts.append(peaks[0]-(n-1))
+    return np.array(corrs).T, np.array(sampleshifts)
+
+
+            
+        

asmu/generator.py

@@ -0,0 +1,158 @@
+import numpy as np
+import scipy as sp
+import threading
+import queue
+
+class Generator():
+    def __init__(self, queuesize) -> None:
+        self._q = queue.Queue(queuesize)
+        self._prefill_queue()
+
+    def get_queue(self) -> queue.Queue:
+        return self._q.get_nowait()
+
+    def _prefill_queue(self) -> None:
+        while self._q.full() is False:
+           self.refill_queue(block=False)
+
+    def refill_queue(self, block=True) -> None:
+        #if self._q.full() is False:
+        data = self._gen()
+        self._q.put(data, block=block, timeout=0.2)
+
+    def start_refill_thread(self, stream):
+        def runner(self, stream):
+            while stream.active:
+                try:
+                    self.refill_queue()
+                except queue.Full:
+                    pass
+        threading.Thread(target=runner, args=(self, stream, )).start()
+    
+    def _gen(self) -> None:
+        return None
+
+class Chirp(Generator):
+    def __init__(self, rate: int, chunk: int, f0: float, f1: float, duration: int, queuesize: int=10) -> None:
+        self._rate = rate
+        self._chunk = chunk
+        
+        t = np.arange(0, int(duration*rate)) / rate
+        self._chirp = sp.signal.chirp(t, f0=f0, t1=duration, f1=f1, method="logarithmic")
+        self._idx = 0
+        super().__init__(queuesize)
+    
+    def _gen(self) -> np.ndarray:
+        data = self._chirp[self._idx:self._idx+self._chunk]
+        self._idx += self._chunk
+
+        length = np.ma.size(data, axis=0)
+        if data.size == 0:
+            return None
+        elif length < self._chunk:
+            pad = np.zeros(self._chunk)
+            pad[:length] = data
+            return pad
+        else:
+            return data
+
+
+class SineBurst(Generator):
+    def __init__(self, rate: int, chunk: int, f: float, n: int, loop: float=-1, queuesize: int=10) -> None:
+        self._rate = rate
+        self._chunk = chunk
+        self._freq = f
+
+        # generate wave parameters
+        self._omegas = np.linspace(0, 2*np.pi*f*chunk/rate, chunk, endpoint=False, dtype=np.float32)
+        self._phi = 0
+        self._maxang = 2*np.pi*n
+        self._loopang = 2*np.pi*loop*f
+
+        super().__init__(queuesize)
+
+    @property
+    def burstlen(self):
+        return self._rate/(2*np.pi*self._freq)*self._maxang
+
+    def _gen(self) -> np.ndarray:
+        ang = self._omegas + self._phi
+        if self._loopang > 0: ang = np.mod(ang, self._loopang)
+        sineburst = np.sin(ang)
+        sineburst[ang > self._maxang] = 0
+        self._phi += 2*np.pi*self._freq*self._chunk/self._rate
+        return sineburst
+    
+class SincBurst(Generator):
+    def __init__(self, rate: int, chunk: int, f: float, n: int, loop: float=-1, queuesize: int=10) -> None:
+        self._rate = rate
+        self._chunk = chunk
+        self._freq = f
+
+        # generate wave parameters
+        self._omegas = np.linspace(0, 2*np.pi*f*chunk/rate, chunk, endpoint=False, dtype=np.float32)
+        self._phi = 0
+        self._maxang = 2*np.pi*n
+        self._loopang = 2*np.pi*loop*f
+
+        super().__init__(queuesize)
+
+    @property
+    def burstlen(self):
+        return self._rate/(2*np.pi*self._freq)*self._maxang
+
+    def _gen(self) -> np.ndarray:
+        ang = self._omegas + self._phi
+        if self._loopang > 0: ang = np.mod(ang, self._loopang)
+        sincburst = np.sinc((ang-self._maxang/2)/np.pi)
+        sincburst[ang > self._maxang] = 0
+        self._phi += 2*np.pi*self._freq*self._chunk/self._rate
+        return sincburst
+        
+class WhiteNoise(Generator):
+    def __init__(self, chunk: int, queuesize: int=10) -> None:
+        self._chunk = chunk
+
+        super().__init__(queuesize)
+
+    def _gen(self) -> np.ndarray:
+        fwhite = np.fft.rfft(np.random.randn(self._chunk))
+        return np.clip(np.fft.irfft(fwhite)/4, -1, 1)
+    
+class PinkNoise(Generator):
+    def __init__(self, chunk: int, queuesize: int=10) -> None:
+        self._chunk = chunk
+
+        super().__init__(queuesize)
+
+    def _gen(self) -> np.ndarray:
+        fwhite = np.fft.rfft(np.random.randn(self._chunk))
+
+        # apply noise color and normalize for power
+        f = np.fft.rfftfreq(self._chunk)
+        S = 1/np.where(f == 0, float('inf'), np.sqrt(f))
+        S = S / np.sqrt(np.mean(S**2))
+        fpink = fwhite * S
+
+        return np.clip(np.fft.irfft(fpink)/4, -1, 1)
+
+class Sine(Generator):
+    def __init__(self, rate: int, chunk: int, f: float, queuesize: int=10) -> None:
+        self._rate = rate
+        self._chunk = chunk
+        self._freq = f
+
+        # generate wave parameters
+        self._omegas = np.linspace(0, 2*np.pi*f*chunk/rate, chunk, endpoint=False, dtype=np.float32)
+        self._phi = 0
+
+        super().__init__(queuesize)
+
+    def _gen(self) -> np.ndarray:
+        ang = self._omegas + self._phi
+        self._phi += 2*np.pi*self._freq*self._chunk/self._rate
+        self._phi %= 2*np.pi
+        return np.sin(ang)
+
+                    
+        

asmu/inout.py

@@ -0,0 +1,79 @@
+import numpy as np
+
+class IO():
+    def __init__(self, IOsetup: dict) -> None:
+        self._IOSetup = IOsetup
+
+    def __repr__(self):
+        return self.name
+
+    @property
+    def name(self):
+        return self._IOSetup["name"]
+
+    @property
+    def channel(self):
+        return int(self._IOSetup["channel"])
+
+    @property
+    def color(self):
+        return self._IOSetup["color"]
+    @color.setter
+    def color(self, value):
+        self._IOSetup["color"] = str(value)
+    
+    @property
+    def pos(self):
+        return np.array(self._IOSetup["pos"])
+    @pos.setter
+    def pos(self, value):
+        self._IOSetup["pos"] = value
+
+    @property
+    def reference(self):
+        try:
+            return bool(self._IOSetup["reference"])
+        except KeyError:
+            return False
+    @reference.setter
+    def reference(self, value):
+        if value:
+            self._IOSetup["reference"] = True
+        else:
+            try:
+                del self._IOSetup["reference"]
+            except KeyError:
+                pass
+
+class Input(IO):
+    def __init__(self, inputSetup: dict) -> None: 
+        super().__init__(inputSetup)
+        self._inputSetup = inputSetup
+
+    @property
+    def cSPL(self):
+        return float(self._inputSetup["cSPL"])
+    @cSPL.setter
+    def cSPL(self, value:float):
+        self._inputSetup["cSPL"] = value
+
+    @property
+    def kSPL(self):
+        return int(self._inputSetup["kSPL"])
+    @kSPL.setter
+    def kSPL(self, value:int):
+        self._inputSetup["kSPL"] = value 
+
+    @property
+    def cFR(self):
+        return self._inputSetup["cFR"]
+    @cFR.setter
+    def cFR(self, value):
+        self._inputSetup["cFR"] = np.array(value)
+
+
+class Output(IO):
+    def __init__(self, outputSetup: dict) -> None: 
+        super().__init__(outputSetup)
+
+        

asmu/interface.py

@@ -0,0 +1,107 @@
+import numpy as np
+import sounddevice as sd
+
+DEBUG = True
+
+class Interface():
+    def __init__(self, interfaceSetup: dict) -> None:
+        """Class for Audiointerface communication and settings.
+
+        Args:
+            interfaceSetup (dict): Interface setup.
+        """
+        self._interfaceSetup = interfaceSetup
+        self.callback = None
+
+    @property
+    def name(self):
+        return self._interfaceSetup["name"]
+
+    @property
+    def device(self):
+        return self._interfaceSetup["device"]
+    @device.setter
+    def device(self, value):
+        self._interfaceSetup["device"] = value
+
+    @property
+    def rate(self):
+        return int(self._interfaceSetup["rate"])
+
+    @property
+    def chunk(self):
+        return int(self._interfaceSetup['chunk'])
+    
+    # SOUNDDEVICE
+    def initSounddevice(self, channels: tuple[int, int]) -> None:
+        sd.default.samplerate = self.rate
+        sd.default.dtype = np.float32
+        sd.default.blocksize = self.chunk
+        try:
+            sd.default.device = self.device # TODO - different input and output device
+        except KeyError:
+            print("interface - no device specified, using default")
+            return
+
+        if "ASIO" in self.device:
+            if channels[0]:
+                inChannels = [c - 1 for c in channels[0]] # convert to channel names starting with 0
+                asio_in = sd.AsioSettings(channel_selectors=inChannels)
+
+                if not channels[1]:
+                    sd.default.extra_settings = asio_in
+                    sd.default.channels = len(inChannels)
+                    return
+
+            if channels[1]:
+                outChannels = [c - 1 for c in channels[1]]
+                asio_out = sd.AsioSettings(channel_selectors=outChannels)
+
+                if not channels[0]:
+                    sd.default.extra_settings = asio_out
+                    sd.default.channels = len(outChannels)
+                    return
+            
+            if channels[0] and channels[1]:
+                sd.default.extra_settings = (asio_in, asio_out)
+                sd.default.channels = (len(inChannels), len(outChannels))
+                return
+            
+        elif "CoreAudio" in self.device: # TODO - update this
+            inChannels = [c - 1 for c in channels[0]] # convert to channel names starting with 0
+            ca_in = sd.CoreAudioSettings(channel_map=inChannels)
+
+            if channels[1]:
+                outChannels = [-1]*sd.query_devices(device=self.device, kind="output")["max_output_channels"]
+                for idx, c in enumerate(channels[1]):
+                    outChannels[c-1] = idx
+                ca_out = sd.CoreAudioSettings(channel_map=outChannels)
+
+                sd.default.extra_settings = (ca_in, ca_out)
+                sd.default.channels = (len(inChannels), len(outChannels))
+            else:
+                sd.default.extra_settings = ca_in
+                sd.default.channels = len(inChannels)
+        else:
+            raise NotImplementedError
+                
+    def _callback(self, indata: np.ndarray, outdata: np.ndarray, frames: int, time, status) -> None:
+        if status:
+            print(status, flush=True)
+
+        outdata.fill(0)
+        self.callback(indata, outdata, frames, time)
+
+    def start_stream(self, channels:tuple, finished_callback=None) -> None:  
+        self.initSounddevice(channels)   
+        return sd.Stream(callback=self._callback, finished_callback=finished_callback)
+    
+    def stop_stream(self) -> None:
+        raise sd.CallbackStop
+
+    
+
+
+    
+
+       

asmu/recording.py

@@ -0,0 +1,195 @@
+import json
+import numpy as np
+import queue
+import soundfile as sf
+import tempfile
+import shutil
+import os
+import threading
+
+from datetime import datetime
+
+class Recording():
+    def __init__(self, recordingPath: str, mode: str, setupName: str, channels: int, rate: int, chunk: int, queuesize=10) -> None:
+        """Constructs all the necessary attributes for the Recording object.
+
+        Args:
+            recordingPath (str): Path to an .asm_rec file
+            mode ("r", "w"): Set recording mode to read "r", or write "w"
+            setupName (str): Name of the current setup for comparison with the recordings setupName
+            channels (int): Channel count
+            rate (int): Samplerate
+            chunk (int): Chunksize
+            queuesize (int, optional): The size of the internal queue. Defaults to 10.
+        """
+        # path and recording info
+        self._path, file = os.path.split(recordingPath)
+        self._name = file.replace(".asm_recording", "") # extract name without file ending
+        now = datetime.now()
+        self._recordingData = {
+            "setupName" : setupName,
+            "date" : now.strftime("%d/%m/%Y"),
+            "time" : now.strftime("%H:%M:%S"),
+        }
+
+        # save parameters
+        self._mode = mode
+        self._rate = rate
+        self._chunk = chunk
+        self._channels = channels
+
+        # create buffer queue for transfer between threads
+        self._rq = queue.Queue(queuesize)
+        self._pq = queue.Queue(queuesize)
+
+    def __enter__(self):
+        if self._mode=="r":
+            self.load_file(self.setupName)
+        elif self._mode=="w":
+            self.create_file()
+        else:
+            raise Exception(f"Recording - invalid mode specified, use \"r\" or \"w\".")
+
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        self._filesf.close()
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def path(self):
+        return self._path
+    
+    @property 
+    def setupName(self):
+        return self._recordingData["setupName"]
+
+    @property
+    def date(self):
+        return self._recordingData["date"]
+
+    @property
+    def time(self):
+        return self._recordingData["time"]
+    
+    @property
+    def extra_settings(self):
+        """:obj:`dict` of :obj:`dict`: Store extra settings in .asm_rec file.
+
+        Setting the dict overwrites existing extra_settings!
+        """
+        return self._recordingData["extra_settings"]
+    @extra_settings.setter
+    def extra_settings(self, value):
+        self._recordingData["extra_settings"] = value
+    
+    @property
+    def latency(self):
+        try:
+            return self._recordingData["latency"]
+        except KeyError:
+            return None
+    @latency.setter
+    def latency(self, value):
+        self._recordingData["latency"] = int(value)
+    
+    @property
+    def data(self):
+        # process full queue
+        while not self._rq.empty():
+            self.process_queue()
+            
+        self._filesf.flush()
+        self._filesf.seek(0)
+        return self._filesf.read(dtype="float32", always_2d=True)
+
+# LATENCY
+    def set_latency(self, time):
+        self.latency = round((time.outputBufferDacTime-time.inputBufferAdcTime)*self._rate + 1) # the +1 was measured experimentally (could be the cable?)
+
+# PLAYBACK
+    def get_queue(self):
+        return self._pq.get_nowait()
+
+    def prefill_queue(self):
+        self.empty_queue()
+        self._filesf.seek(0)
+        while self._pq.full() is False:
+           self.refill_queue(block=False)
+
+    def refill_queue(self, block=True):
+        if self._pq.full() is False:
+            data = self._gen()
+            self._pq.put(data, block=block)
+
+    def empty_queue(self):
+        while not self._pq.empty():
+            self.get_queue()
+        
+    def _gen(self):
+        data = self._filesf.read(self._chunk, dtype="float32", always_2d=True)
+        length = np.ma.size(data, axis=0)
+        if data.size == 0:
+            return None
+        elif length < self._chunk:
+            pad = np.zeros((self._chunk, self._channels))
+            pad[:length, :] = data
+            return pad
+        else:
+            return data
+
+# RECORDING
+    def create_file(self, subtype="PCM_24"):
+        self._file = tempfile.NamedTemporaryFile(prefix=f"{self.name}", suffix='.wav', dir="", delete=True)
+        self._filesf = sf.SoundFile(self._file, mode='w+', samplerate=self._rate, channels=self._channels, subtype=subtype, format="WAV")
+    
+    def put_queue(self, data):
+        self._rq.put(data.copy())
+
+    def process_queue(self):
+        self._filesf.write(self._rq.get(timeout=0.2))
+
+    def start_process_thread(self, stream):
+        def runner(self, stream):
+            while stream.active:
+                try:
+                    self.process_queue()
+                except queue.Empty:
+                    pass
+        threading.Thread(target=runner, args=(self, stream, )).start()
+
+# SAVE/LOAD
+    def save_file(self, extra_settings={}):
+        # add new extra_settings
+        if extra_settings:
+            self.extra_settings = extra_settings
+            
+        # save .asm_rec file
+        with open(f"{self.path}/{self.name}.asm_rec", 'w') as file:
+            file.write(json.dumps(self._recordingData))
+
+        # process full queue
+        while not self._rq.empty():
+            self.process_queue()
+
+        # persist temporary files in specified recording location 
+        self._file.flush()
+        self._file.seek(0)
+        with open(f"{self.path}/{self.name}.wav", 'wb') as file:
+            shutil.copyfileobj(self._file, file)
+
+    def load_file(self, currentSetupName):
+        # open .asm_rec file
+        with open(f"{self.path}/{self.name}.asm_rec", 'r') as file:
+            self._recordingData = json.load(file)
+
+        # check if setups are equal
+        if self.setupName != currentSetupName:
+            raise Exception(f"Recording - current setup does not match setup of {self.setupName}.asm_rec")
+
+        # open .wav file
+        self._filesf = sf.SoundFile(f"{self.path}/{self.name}.wav")
+        self.prefill_queue()

asmu/setup.py

@@ -0,0 +1,79 @@
+import json
+import numpy as np
+import os
+
+class Setup():
+    def __init__(self, setupPath: str) -> None:
+        """Class to handle setups.
+
+        Args:
+            setupPath (str): Path to .asm_setup file
+        """
+        self._path, file = os.path.split(setupPath)
+        self._name = file.replace(".asm_setup", "") # extract name without file ending
+        self.load_file(setupPath)
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def path(self):
+        return self._path
+
+    @property
+    def inputs(self):
+        try:
+            value = self._setup["inputs"]
+            return value
+        except KeyError:
+            return []
+
+    @property
+    def outputs(self):
+        try:
+            value = self._setup["outputs"]
+            return value
+        except KeyError:
+            return []
+
+    @property
+    def interface(self):
+        return self._setup["interface"]
+
+    def load_file(self, setupPath):
+        with open(setupPath, "r") as file:
+            self._setup = json.load(file)
+        
+        # load numpy arrays from external files
+        for io in self.inputs+self.outputs:
+            try:
+                path = f"{self.path}/{self.name}/cFR_{io["name"]}.npy"
+                io["cFR"] = np.load(path)
+            except FileNotFoundError:
+                pass
+
+    def save_file(self, setupPath=None):
+        if setupPath is not None:
+            self.__init__(setupPath)
+        setupPath = f"{self.path}/{self.name}.asm_setup"
+
+        # save numpy arrays to external files
+        for io in self.inputs+self.outputs:
+            try:
+                if isinstance(io["cFR"], np.ndarray):
+                    path = f"{self.path}/{self.name}/cFR_{io["name"]}.npy"
+                    np.save(path, io["cFR"])
+                    io.pop("cFR")
+            except KeyError:
+                pass
+
+        # save .asm_setup file
+        with open(setupPath, 'w') as file:
+            file.write(json.dumps(self._setup, sort_keys=True, indent=4, separators=(',', ': ')))
+
+        
+
+    
+
+