Example #1
0
    def dummyFill(self):
        # Preenche o dicionário de dados medidos com sinais nulos.
        dummyFill = cp.deepcopy(self.MS.excitationSignals)
#        for key in dummyFill:
        for sourceCode in self.MS.outChannel:
            for rN in range(1,self.MS.receiversNumber+1):
                self.measuredData[sourceCode+'R'+str(rN)] = {} # Insere as chaves referente as configurações fonte receptor
                for key in self.MS.excitationSignals:
                    self.measuredData[sourceCode+'R'+str(rN)][key] = {\
                                      'binaural':\
                                      [pytta.SignalObj(np.random.rand(len(dummyFill[key].timeSignal),2),domain='time',samplingRate=self.MS.samplingRate),
                                      pytta.SignalObj(np.random.rand(len(dummyFill[key].timeSignal),2),domain='time',samplingRate=self.MS.samplingRate),
                                      pytta.SignalObj(np.random.rand(len(dummyFill[key].timeSignal),2),domain='time',samplingRate=self.MS.samplingRate)],
                                       'hc':
                                      [pytta.SignalObj(np.random.rand(len(dummyFill[key].timeSignal),1),domain='time',samplingRate=self.MS.samplingRate),
                                      pytta.SignalObj(np.random.rand(len(dummyFill[key].timeSignal),1),domain='time',samplingRate=self.MS.samplingRate),
                                      pytta.SignalObj(np.random.rand(len(dummyFill[key].timeSignal),1),domain='time',samplingRate=self.MS.samplingRate)]} # Insere as chaves referentes ao sinal de excitação e tipo de gravação
                    self.status[sourceCode+'R'+str(rN)][key] = {'binaural':True,'hc':True} # Insere as chaves referentes ao sinal de excitação e tipo de gravação
        noisefloorstr = 'pytta.SignalObj(np.random.rand(self.MS.noiseFloorTp*self.MS.samplingRate,1),domain="time",samplingRate=self.MS.samplingRate)'
        self.measuredData['noisefloor'] = [[eval(noisefloorstr),eval(noisefloorstr),eval(noisefloorstr)],
                         [eval(noisefloorstr),eval(noisefloorstr),eval(noisefloorstr)]] # Cria lista de medições de ruído de fundo
        self.status['noisefloor'] = True # Cria lista de medições de ruído de fundo
        self.measuredData['calibration'] = {} # Cria dicionário com os canais de entrada da medição
        calibrationstr = 'pytta.SignalObj(np.random.rand(self.MS.calibrationTp*self.MS.samplingRate,1),domain="time",samplingRate=self.MS.samplingRate)'
        for chN in self.MS.inChName:
            self.measuredData['calibration'][chN] = [[eval(calibrationstr),eval(calibrationstr),eval(calibrationstr)],
            [eval(calibrationstr),eval(calibrationstr),eval(calibrationstr)]]# Cria uma lista de calibrações para cada canal
            self.status['calibration'][chN] = True
Example #2
0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Jun 16 16:39:48 2019

@author: joaovitor
"""

import pytta
import numpy as np
from scipy.io import loadmat
from matplotlib import pyplot as plt

f = loadmat('RIS/RI_mono_1.mat')

mySignal = pytta.SignalObj(f['MonoRIS1_time'], 'time', 44100)

myRT = pytta.rooms.RT(20, mySignal, 3)
myD50 = pytta.rooms.D(50, mySignal, 1)
myC80 = pytta.rooms.C(80, mySignal, 6)
Example #3
0
# Carregando sinal de música
excitationSignals['musica'] = pytta.read_wav(
    'audio/Piano Over the rainbow Mic2 SHORT_edited.wav')
# Carregando sinal de fala
excitationSignals['fala'] = pytta.read_wav(
    'audio/Voice Sabine Short_edited.WAV')

# %% Carrega sensibilidade do microfone para compensação na cadeia de entrada
loadtxt = np.loadtxt(fname='14900_no_header.txt')
mSensFreq = loadtxt[:, 0]
mSensdBMag = loadtxt[:, 1]
# plt.semilogx(mSensFreq, mSensdBMag)

# %% Carrega resposta da fonte para compensação na cadeia de saida
matLoad = io.loadmat('hcorrDodecCTISM2m_Brum.mat')
ir = pytta.SignalObj(matLoad['hcorrDodecCTISM2m'], 'time', 44100)
sSensFreq = ir.freqVector
sourceSens = 1 / np.abs(ir.freqSignal)[:, 0]
normIdx = np.where(sSensFreq > 1000)[0][0]
sourceSens = sourceSens / sourceSens[normIdx]
sSensdBMag = 20 * np.log10(sourceSens)
# plt.semilogx(sSensFreq, sSensdBMag)

# %% Cria novo setup de medição e inicializa objeto de dados, que gerencia o
# MeasurementSetup e os dados da medição em disco
MS = rmr.MeasurementSetup(
    name='med-teste',  # Nome da medição
    samplingRate=44100,  # [Hz]
    # Sintaxe : device = [<in>,<out>] ou <in/out>
    # Utilize pytta.list_devices() para listar
    # os dispositivos do seu computador.
Example #4
0
    def save(self, dataObj):
        # Desmembra o SignalObj measureTake de 4 canais em 3 SignalObj referentes ao arranjo biauricular
        # em uma posição e ao centro da cabeça em duas outras posições
        if self.kind == 'newpoint' or self.kind == 'noisefloor':
            chcont = 0
            self.binaural = []
            self.hc1 = []
            self.hc2 = []
            if self.channelStatus[0] and self.channelStatus[1]:
                for i in range(0, self.averages):
                    self.binaural.append(
                        pytta.SignalObj(
                            self.measuredTake[i].timeSignal[:,
                                                            chcont:chcont + 2],
                            'time',
                            samplingRate=self.measuredTake[i].samplingRate,
                            comment=self.excitation))
                    self.binaural[-1].channels[0].name = self.MS.inChName[0]
                    self.binaural[-1].channels[1].name = self.MS.inChName[1]
                    if self.kind == 'noisefloor':
                        SR = [self.receiver[0], self.receiver[1]]
                    else:
                        SR = [
                            self.source + self.receiver[0],
                            self.source + self.receiver[1]
                        ]
                    self.binaural[i].sourceReceiver = SR
                    self.binaural[i].temp = self.measuredTake[i].temp
                    self.binaural[i].RH = self.measuredTake[i].RH
                    self.binaural[i].timeStamp = self.measuredTake[i].timeStamp
                chcont = chcont + 2
            if self.channelStatus[2]:
                for i in range(0, self.averages):
                    self.hc1.append(
                        pytta.SignalObj(
                            self.measuredTake[i].timeSignal[:, chcont],
                            'time',
                            samplingRate=self.measuredTake[i].samplingRate,
                            comment=self.excitation))
                    self.hc1[-1].channels[0].name = self.MS.inChName[2]
                    if self.kind == 'noisefloor':
                        SR = self.receiver[2]
                    else:
                        SR = self.source + self.receiver[2]
                    self.hc1[i].sourceReceiver = SR
                    self.hc1[i].temp = self.measuredTake[i].temp
                    self.hc1[i].RH = self.measuredTake[i].RH
                    self.hc1[i].timeStamp = self.measuredTake[i].timeStamp
                chcont = chcont + 1
            if self.channelStatus[3]:
                for i in range(0, self.averages):
                    self.hc2.append(
                        pytta.SignalObj(
                            self.measuredTake[i].timeSignal[:, chcont],
                            'time',
                            samplingRate=self.measuredTake[i].samplingRate,
                            comment=self.excitation))
                    self.hc2[-1].channels[0].name = self.MS.inChName[3]
                    if self.kind == 'noisefloor':
                        SR = self.receiver[3]
                    else:
                        SR = self.source + self.receiver[3]
                    self.hc2[i].sourceReceiver = SR
                    self.hc2[i].temp = self.measuredTake[i].temp
                    self.hc2[i].RH = self.measuredTake[i].RH
                    self.hc2[i].timeStamp = self.measuredTake[i].timeStamp

        # Salva dados no dicionário do objeto de dados dataObj
        taketopkl = {'measuredData': {}, 'status': {}}
        if self.kind == 'newpoint':
            # Adiciona cada uma das três posições de receptor da última tomada de medição
            if self.channelStatus[0] and self.channelStatus[1]:
                dataObj.measuredData[self.binaural[0].sourceReceiver[0]][
                    self.binaural[0].comment]['binaural'] = self.binaural
                taketopkl['measuredData'][
                    self.binaural[0].sourceReceiver[0]] = {
                        self.binaural[0].comment: {
                            'binaural': self.binaural
                        }
                    }
                dataObj.status[self.binaural[0].sourceReceiver[0]][
                    self.binaural[0].comment]['binaural'] = True
                taketopkl['status'][self.binaural[0].sourceReceiver[0]] = {
                    self.binaural[0].comment: {
                        'binaural': True
                    }
                }
            if self.channelStatus[2]:
                dataObj.measuredData[self.hc1[0].sourceReceiver][
                    self.hc1[0].comment]['hc'] = self.hc1
                taketopkl['measuredData'][self.hc1[0].sourceReceiver] = {
                    self.hc1[0].comment: {
                        'hc': self.hc1
                    }
                }
                dataObj.status[self.hc1[0].sourceReceiver][
                    self.hc1[0].comment]['hc'] = True
                taketopkl['status'][self.hc1[0].sourceReceiver] = {
                    self.hc1[0].comment: {
                        'hc': True
                    }
                }
            if self.channelStatus[3]:
                dataObj.measuredData[self.hc2[0].sourceReceiver][
                    self.hc2[0].comment]['hc'] = self.hc2
                taketopkl['measuredData'][self.hc2[0].sourceReceiver] = {
                    self.hc2[0].comment: {
                        'hc': self.hc2
                    }
                }
                dataObj.status[self.hc2[0].sourceReceiver][
                    self.hc2[0].comment]['hc'] = True
                taketopkl['status'][self.hc2[0].sourceReceiver] = {
                    self.hc2[0].comment: {
                        'hc': True
                    }
                }

        if self.kind == 'noisefloor':
            newNF = {}
            if self.channelStatus[0] and self.channelStatus[1]:
                newNF[self.binaural[0].sourceReceiver[0]] = self.binaural
            if self.channelStatus[2]:
                newNF[self.hc1[0].sourceReceiver] = self.hc1
            if self.channelStatus[3]:
                newNF[self.hc2[0].sourceReceiver] = self.hc2
            dataObj.measuredData['noisefloor'].append(newNF)
            taketopkl['measuredData']['noisefloor'] = newNF
            dataObj.status['noisefloor'] = True
            taketopkl['status']['noisefloor'] = True

        if self.kind == 'calibration':
            self.calibAverages = []
            # Pegando o nome do canal calibrado
            j = 0
            for i in self.channelStatus:
                if i:
                    self.inChName = [self.MS.inChName[j]]
                j = j + 1
            for i in range(0, self.averages):
                self.calibAverages.append(
                    pytta.SignalObj(
                        self.measuredTake[i].timeSignal[:, 0],
                        'time',
                        samplingRate=self.measuredTake[i].samplingRate,
                        #                                      channelName=self.inChName,
                        comment=self.excitation))
                self.calibAverages[i].channels[0].name = self.MS.inChName[0]
                #                self.calibAverages[i].sourceReceiver = self.sourceReceiver[2]
                self.calibAverages[i].temp = self.measuredTake[i].temp
                self.calibAverages[i].RH = self.measuredTake[i].RH
                self.calibAverages[i].timeStamp = self.measuredTake[
                    i].timeStamp
            dataObj.measuredData['calibration'][self.inChName[0]].append(
                self.calibAverages)
            taketopkl['measuredData']['calibration'] = {
                self.inChName[0]: self.calibAverages
            }
            dataObj.status['calibration'][self.inChName[0]] = True
            taketopkl['status']['calibration'] = {self.inChName[0]: True}
        if self.tempHumid != None:
            self.tempHumid.stop()

        # Save last take to file
        mypath = getcwd() + '/' + self.MS.name + '/'
        mytakefilesprefix = self.MS.name + '_D_take-'
        myMSfile = self.MS.name + '_MS'
        if not exists(mypath):
            mkdir(mypath)
        myfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
        lasttake = 0
        saveMS = True
        for file in myfiles:
            if mytakefilesprefix in file:
                newlasttake = file.replace(mytakefilesprefix, '')
                newlasttake = int(newlasttake.replace('.pkl', ''))
                if newlasttake > lasttake:
                    lasttake = newlasttake
            if myMSfile in file:
                saveMS = False
        if saveMS:
            msD = {
                'averages': self.MS.averages,
                'calibrationTp': self.MS.calibrationTp,
                'device': self.MS.device,
                'excitationSignals': self.MS.excitationSignals,
                'freqMax': self.MS.freqMax,
                'freqMin': self.MS.freqMin,
                'inChName': self.MS.inChName,
                'inChannel': self.MS.inChannel,
                'measurementObjects': self.MS.measurementObjects,
                'name': self.MS.name,
                'noiseFloorTp': self.MS.noiseFloorTp,
                'outChannel': self.MS.outChannel,
                'receiversNumber': self.MS.receiversNumber,
                'samplingRate': self.MS.samplingRate,
                'sourcesNumber': self.MS.sourcesNumber
            }
            output = open(mypath + myMSfile + '.pkl', 'wb')
            pickle.dump(msD, output)
            output.close()
        output = open(mypath + mytakefilesprefix + str(lasttake + 1) + '.pkl',
                      'wb')
        pickle.dump(taketopkl, output)
        output.close()
Example #5
0
 def renew_audio(self):
     self.audio = pytta.SignalObj(self.file.read(), 'time',
                                  self.file.samplerate)
     self.file.close()
     return