Beispiel #1
0
            noise_microphone = 0.003
            noise_environment = 0.04
            noise_source = 0.01
            source_pos = getPoint(dis * np.sin(angle_radians(ang)),
                                  dis * np.cos(angle_radians(ang)))
            config = updateConfig(config, micA, micB, noise_microphone,
                                  noise_environment, noise_source, source_pos)

            # Starte Simulation
            loaded = simulate(config, config["source_position"],
                              signal_function)
            signals = loaded.get_measurements()
            meta = loaded.get_meta_data()
            signalA = signals[0]
            signalB = signals[1]
            signalAF = butterWorthFilter(signalA, meta["sampling_rate"], 1500)
            signalBF = butterWorthFilter(signalB, meta["sampling_rate"], 1500)

            TDOA_CSOM, t, csom = tdoa_csom(signalAF,
                                           signalBF,
                                           fs=meta["sampling_rate"],
                                           window=1000)
            TDOA_real = getRealTDOA(source_pos, micA, micB)
            a, b, c, SNR = getSNR(signalAF)

            SNRls.append(SNR)
            TDOA_realls.append(TDOA_real)
            TDOA_csomls.append(TDOA_CSOM)

        print(dis, ";", ang, ";", source_pos, ";", np.average(SNRls), ";",
              np.std(SNRls), ";", np.average(TDOA_realls), ";",
Beispiel #2
0
            signalsPower = pSigna

            # Determine TDOA
            idxA = 8
            idxB = 2
            idxC = 2
            idxD = 4
            micA = micList[idxA - 1]
            micB = micList[idxB - 1]
            micC = micList[idxC - 1]
            micD = micList[idxD - 1]
            signalA = data[idxA]
            signalB = data[idxB]
            signalC = data[idxC]
            signalD = data[idxD]
            signalAF = butterWorthFilter(signalA, meta_data["sampling_rate"],
                                         2000)
            signalBF = butterWorthFilter(signalB, meta_data["sampling_rate"],
                                         2000)
            signalCF = butterWorthFilter(signalC, meta_data["sampling_rate"],
                                         2000)
            signalDF = butterWorthFilter(signalD, meta_data["sampling_rate"],
                                         2000)
            TDOA_CSOM1, t, csom = tdoa_csom(signalAF,
                                            signalBF,
                                            fs=meta_data["sampling_rate"],
                                            window=200)
            TDOA_CSOM2, t, csom = tdoa_csom(signalCF,
                                            signalDF,
                                            fs=meta_data["sampling_rate"],
                                            window=200)
            TDOA_real1 = getRealTDOA(source_pos, micA, micB)
            noise_source = 0.01
            source_pos = getPoint(dis * np.sin(angle_radians(ang)),
                                  dis * np.cos(angle_radians(ang)))
            config = updateConfig(config, micList, noise_microphone,
                                  noise_environment, noise_source, source_pos)

            # Signal Simulation
            loaded = simulate(config, config["source_position"],
                              signal_function)
            signals = loaded.get_measurements()
            meta = loaded.get_meta_data()
            signalsFiltered = list()
            signalsPower = list()
            signalsSNR = list()
            for s in signals:
                sf = butterWorthFilter(s, meta["sampling_rate"], 2000)
                powerSig, powerNoi, snrFac, snrDB = getSNR(sf)
                signalsFiltered.append(sf)
                signalsPower.append(powerSig)
                signalsSNR.append(snrDB)

            # Calculate True K
            K_true = 0
            for k in range(0, len(micList)):
                K_true += signalsPower[k] * distance(
                    micList[k], source_pos) * distance(micList[k], source_pos)
            K_true /= len(micList)

            # Calculate K estimation
            K_estim_exakt = list()
            K_estim_noise = list()