Python getMicrophonePair_DOA_Intersection_linear Examples

Example #1

File: SslLibrary.py Project: ProjektseminarAUT-Gruppe10/Sound-Source-Localization-for-Outdoor-Far-distance-Applications

def SSL_TDOA_LN(micPosList, tdoa1, tdoa2, c_speed):
    # Get Microphone Points
    micAP = micPosList[0]
    micBP = micPosList[1]
    micCP = micPosList[2]
    micDP = micPosList[3]
    average = (micAP + micBP + micCP + micDP) / 4

    # Calculate way_tdoa1 and way_tdoa2
    ds1 = tdoa1 * c_speed
    ds2 = tdoa2 * c_speed

    # Calculate Linear IntersectionPoints
    m1T = KarstenDOA_calculateSteep_linear_simple(distance(micAP, micBP), ds1)
    m2T = KarstenDOA_calculateSteep_linear_simple(distance(micCP, micDP), ds2)
    pointList, m1_a, m1_b, m2_a, m2_b, b1_a, b1_b, b2_a, b2_b = getMicrophonePair_DOA_Intersection_linear(
        micAP, micBP, micCP, micDP, m1T, m2T)

    # Choose Plausible One = the one that is farest away from microphones
    pointListC = list()
    for p in pointList:
        if (p[1] > 0):
            pointListC.append(p)
    if (distance(pointListC[0], average) < distance(pointListC[1], average)):
        return pointListC[1]
    else:
        return pointListC[0]

Example #2

def SSL_TDOA_LIN(tdoa1, tdoa2, micA, micB, micC, micD):        
    std1 = tdoa1*343.2
    std2 = tdoa2*343.2
    steep1 = KarstenDOA_calculateSteep_linear_simple(distance(micA, micB), std1)
    steep2 = KarstenDOA_calculateSteep_linear_simple(distance(micC, micD), std2)
    solutions, m1_a, m1_b, m2_a, m2_b, b1_a, b1_b, b2_a, b2_b = getMicrophonePair_DOA_Intersection_linear(micA, micB, micC, micD, steep1, steep2)
    estimation = plausibleFilter_TDOA(solutions)
    return estimation

Example #3

File: ExperimentEnvironment.py Project: ProjektseminarAUT-Gruppe10/Sound-Source-Localization-for-Outdoor-Far-distance-Applications

def SSL_TDOA_LIN(s_tdoaMAT, micPosList, indA, indB, indC, indD):
    std1 = s_tdoaMAT[indB][indA]
    std2 = s_tdoaMAT[indD][indC]
    rstd1 = getRealDeltaS(source_pos, micPosList[indA], micPosList[indB])
    rstd2 = getRealDeltaS(source_pos, micPosList[indC], micPosList[indD])
    print("STDOA 1: ", std1, rstd1)
    print("STDOA 2: ", std2, rstd2)
    steep1 = KarstenDOA_calculateSteep_linear_simple(
        distance(micList[indA], micList[indB]), s_tdoaMAT[indB][indA])
    steep2 = KarstenDOA_calculateSteep_linear_simple(
        distance(micList[indC], micList[indD]), s_tdoaMAT[indD][indC])
    solutions, m1_a, m1_b, m2_a, m2_b, b1_a, b1_b, b2_a, b2_b = getMicrophonePair_DOA_Intersection_linear(
        micList[indA], micList[indB], micList[indC], micList[indD], steep1,
        steep2)
    estimation = plausibleFilter_TDOA(solutions)
    return estimation

Example #4

# Calculate TDOA
arr = array_parameters.ArrayParameters(config["microphone_positions"])
tdoa = basic_tdoa.BasicTDOA(loaded, 0, 0.0, arr)
tdoaMAT  = tdoa.tdoa_gcc_phat(0.0)[1][0]
delta_n1 = tdoaMAT[1][0]
delta_n2 = tdoaMAT[3][2]
delta_t1 = delta_n1*meta["sampling_spacing"]
delta_t2 = delta_n2*meta["sampling_spacing"]
delta_s1 = delta_t1*343.2
delta_s2 = delta_t2*343.2

# TDOA LINEAR VERFAHREN
steep1 = KarstenDOA_calculateSteep_linear_simple(distance(micA_pos, micB_pos), delta_s1)
steep2 = KarstenDOA_calculateSteep_linear_simple(distance(micC_pos, micD_pos), delta_s2)
solutions, m1_a, m1_b, m2_a, m2_b, b1_a, b1_b, b2_a, b2_b = getMicrophonePair_DOA_Intersection_linear(micA_pos, micB_pos, micC_pos, micD_pos, steep1, steep2)
estimationLIN = plausibleFilter_TDOA(solutions)

curveA = get_tCurve(micA_pos, micB_pos, delta_s1)
curveB = get_tCurve(micC_pos, micD_pos, delta_s2)
estimationNOL = optimizeIntersectionPoint_nonLinear_numeric(estimationLIN, curveA, curveB)
    
# Kurven zur Darstellung
X_NOL_CURVE1, Y_NOL_CURVE1 = KarstenDOA_calculateCurve_nonlinear(micA_pos, micB_pos, delta_s1, res=0.01, rang=10)
X_LIN_CURVE1, Y_LIN_CURVE1 = KarstenDOA_calculateCurve_linear(micA_pos, micB_pos, delta_s1, res=0.01, rang=10)
X_NOL_CURVE2, Y_NOL_CURVE2 = KarstenDOA_calculateCurve_nonlinear(micC_pos, micD_pos, delta_s2, res=0.01, rang=10)
X_LIN_CURVE2, Y_LIN_CURVE2 = KarstenDOA_calculateCurve_linear(micC_pos, micD_pos, delta_s2, res=0.01, rang=10)

# Plot Data
import matplotlib.pyplot as plt
plt.xlim(-10,10)