Exemple #1
0
def get_diffuse_noise_psd(sensor_distances,
                          fft_size=1024,
                          sample_rate=16000,
                          sound_velocity=343):
    """This function does not calculate a PSD matrix.

    Calculates a spatial coherence matrix for a spherically isotropic sound
    field. This can be interpreted as a normalized PSD matrix.

    The implementation is according to Bitzer, Joerg, and K. Uwe Simmer.
    "Superdirective microphone arrays." In Microphone arrays, pp. 19-38.
    Springer, Berlin, Heidelberg, 2001. In particular Equation (2.17).

    Args:
        sensor_distances: Shape (num_channels, num_channels) in meters.
        fft_size:
        sample_rate:
        sound_velocity: Scalar in meters/ second.

    Returns: spatial coherence matrix
        with shape (num_frequency_bins, num_channels, num_channels)

    """
    f = get_stft_center_frequencies(size=fft_size, sample_rate=sample_rate)
    return np.sinc(2.0 * f[:, None, None] * sensor_distances[None, :, :] /
                   sound_velocity)
Exemple #2
0
def get_steering_vector(
        time_difference_of_arrival,
        stft_size=1024,
        sample_rate=16000,
        normalize=False
):
    """Calculates analytic steering vector from TDoA.

    Can be used when some oracle information is available. Often, DoA
    estimation algorithms rely on steering vectors.

    :param time_difference_of_arrival:
    :param stft_size:
    :param sample_rate:
    :param normalize:
    :return:
    """
    center_frequencies = get_stft_center_frequencies(stft_size, sample_rate)
    steering_vector = numpy.exp(
        -2j * numpy.pi *
        center_frequencies *
        time_difference_of_arrival[..., numpy.newaxis]
    )
    if normalize:
        steering_vector /= np.linalg.norm(
            steering_vector, axis=-2, keepdims=True
        )
    return steering_vector
Exemple #3
0
def get_steering_vector(time_difference_of_arrival,
                        stft_size=1024,
                        sample_rate=16000,
                        normalize=False):
    center_frequencies = get_stft_center_frequencies(stft_size, sample_rate)
    steering_vector = numpy.exp(-2j * numpy.pi * center_frequencies *
                                time_difference_of_arrival[..., numpy.newaxis])
    if normalize:
        steering_vector /= np.linalg.norm(steering_vector,
                                          axis=-2,
                                          keepdims=True)
    return steering_vector