Как выполнить оконную обработку входящего сигнала?

Question

Я использую библиотеку Aubio;Я не могу найти это нигде в документах на aubio.org или в Интернете.При обработке (особенно в моем случае aubio_pitch_detect) Aubio делает что-либо с входящими звуковыми массивами с точки зрения управления окнами, или я должен сам это реализовать?Если мне нужно добавить его, будет приветствоваться простой пример кода окна (или ссылка).

Answer 1

aubio_pitch_do принимает вектор аудиосэмплов в качестве входных данных и выполняет необходимое оконное управление.

Документацию можно найти в заголовочных файлах. В этом случае проверьте файл pitch.h.

Если вам нужно создать окно, вы можете сделать это с помощью new_aubio_window ( size, type ).

Например:

fvec_t * my_new_window = new_aubio_window ( 1024, "hanningz" );

Вот список типов окон, доступных на данный момент:

/** Window types */
typedef enum
{
  aubio_win_rectangle,
  aubio_win_hamming,
  aubio_win_hanning,
  aubio_win_hanningz,
  aubio_win_blackman,
  aubio_win_blackman_harris,
  aubio_win_gaussian,
  aubio_win_welch,
  aubio_win_parzen,
  aubio_win_default = aubio_win_hanningz,
} aubio_window_type;

Answer 2

Это больше вопрос, чем ответ, но я не могу комментировать другие ответы из-за статуса новичка.

Относительно ответов Flavien Volken и buildsucceeded , они оба указывают одно и то же с точки зрения коэффициентов Хэмминга:

0,54 или 0,53836 и 0,46 или 0,46164.
Оба ответа имеют "-" между ними: 0,54 - 0,46.

Пока все хорошо. Теперь посмотрите на это:

(1) Университет Джона Хопкинса говорит: : 0,54 + 0,46
(2) Калифорнийский университет говорит : 0,54 - 0,46
(3) Книга о DSP гласит: 0,54 + 0,46
(4) Википедия говорит: 0,54 + 0,46
(5) математика говорит: 0,54 - 0,46
(6) Пользователь форума говорит: 1.07672 - 0.92328

В полном замешательстве, откуда мы знаем, что сейчас действительно правильно?

Вот ссылки (здесь не может быть более двух реальных ссылок из-за статуса новичка):

  (1): www.jhu.edu/signals/phasors/hpfs7.htm
  (2): www.ece.uci.edu/docs/hspice/hspice_2001_2-220.html
  (3): books.google.de/books?id=ytuUKKVeR88C&pg=PT442&lpg=PT442&dq=hamming%20window%200.54%200.46&source=bl&ots=ecdP7pU8-w&sig=yv9QiCvuWv8vShO-6CjZATx37lA&hl=en&sa=X&ei=M4IJUfvBLsTFtAbQ54GwCw&ved=0CDAQ6AEwATgK
  (4): de.wikipedia.org/wiki/Hamming-Fenster#Hamming-Fenster
  (5): www.mathworks.de/de/help/signal/ref/hamming.html
  (6): forums.oracle.com/forums/message.jspa?messageID=9244422#9244422

Answer 3

Найдено в Перформанс :

// Hamming window
for (size_t i=0; i < FFT_N; i++) {
    m_window[i] = 0.53836 - 0.46164 * std::cos(2.0 * M_PI * i / (FFT_N - 1));
}

Редактировать: Чтобы ответить на вопрос «Боже мой, это + или - или что?», Вам нужно взглянуть немного дальше, чтобы увидеть, умножаете ли вы на грех или cos π*i/FFT_N. Поскольку sin (0) = 0 и cos (0) = 1, вы смотрите на разницу между окном, которое выглядит (приблизительно!) Следующим образом:

или как это:

Обратите внимание, что если поставить один за другим, они оба будут выглядеть так:

То есть , в то время как конкретная обработка, которую вы хотите выполнить для сигнала после вашего окна, может повлиять на то, какую опцию окна вы выберете , на самом деле они не являются принципиально противоположными, просто выровнены по-другому.

Answer 4

Вот мой порт нескольких способов управления для инициализации вектора управления окнами.

include <math.h>  

enum {
WINDOW_RECTANGULAR,
WINDOW_HANN,
WINDOW_HAMMING,
WINDOW_COSINE,
WINDOW_LANCZOS,
WINDOW_TRIANGULAR,
WINDOW_BARTLETT,
WINDOW_GAUSSIAN,
WINDOW_BARTLETT_HANN,
WINDOW_BLACKMAN,
WINDOW_NUTALL,
WINDOW_BLACKMAN_HARRIS,
WINDOW_BLACKMAN_NUTALL,
WINDOW_FLATTOP,
WINDOW_NB
};

    template <class T_Real>
    void computeWindow(T_Real*buffer, int length, int type)
    {

            switch (type)
            {
            case WINDOW_RECTANGULAR :
                    for (int n = 0; n < length; n++){ buffer[n] = 1.0; } break;
            case WINDOW_HANN :
                    for (int n = 0; n < length; n++){ buffer[n] = 0.5*(1.0 - cos(M_PI*2.0*n/(length-1))); } break;
            case WINDOW_HAMMING :
                    for (int n = 0; n < length; n++){ buffer[n] = 0.54-0.46*cos(M_PI*2.0*n/(length-1)); } break;
            case WINDOW_COSINE :
                    for (int n = 0; n < length; n++){ buffer[n] = sin(M_PI*n/(length-1)); } break;
            case WINDOW_LANCZOS :
                    for (int n = 0; n < length; n++){ double x = (2.0*n/(length-1)-1.0); buffer[n] = sin(M_PI*x)/(x*M_PI); } break;
            case WINDOW_TRIANGULAR :
                    for (int n = 0; n < length; n++){ buffer[n] = (2.0/(length+1))*((0.5*(length-1.0))-fabs(n-0.5*(length-1.0)))  ; } break;
            case WINDOW_BARTLETT :
                    for (int n = 0; n < length; n++){ buffer[n] = (2.0/(length-1))*((0.5*(length-1.0))-fabs(n-0.5*(length-1.0)))  ; } break;
            case WINDOW_GAUSSIAN :
                {
                    double fi = 0.5;
                    for (int n = 0; n < length; n++)
                    {
                        double inner = (n-0.5*(length-1))/(0.5*fi*(length-1));
                        double indice = -0.5*inner*inner;
                        buffer[n] = exp(indice);
                    }
                    break;
                }
            case WINDOW_BARTLETT_HANN :
                    for (int n = 0; n < length; n++){ buffer[n] = 0.62-0.48*fabs((double)n/(length-1.0)-0.5)-0.48*cos(M_PI*2.0*n/(length-1));} break;
            case WINDOW_BLACKMAN :
                {
                    double alpha = 0.16;
                    double a0 = 0.5*(1.0-alpha);
                    double a1 = 0.5;
                    double a2 = 0.5*alpha;
                    for (int n = 0; n < length; n++){ buffer[n] = a0 - a1*cos(M_PI*2.0*n/(length-1)) + a2*cos(M_PI*4.0*n/(length-1));} break;
                }
            case WINDOW_NUTALL :
                {
                    double a0 = 0.355768;
                    double a1 = 0.487396;
                    double a2 = 0.144232;
                    double a3 = 0.012604;
                    for (int n = 0; n < length; n++){ buffer[n] = a0 - a1*cos(M_PI*2.0*n/(length-1)) + a2*cos(M_PI*4.0*n/(length-1)) - a3*cos(M_PI*6.0*n/(length-1));} break;
                }

            case WINDOW_BLACKMAN_HARRIS :
                {
                    double a0 = 0.35875;
                    double a1 = 0.48829;
                    double a2 = 0.14128;
                    double a3 = 0.01168;
                    for (int n = 0; n < length; n++){ buffer[n] = a0 - a1*cos(M_PI*2.0*n/(length-1)) + a2*cos(M_PI*4.0*n/(length-1)) - a3*cos(M_PI*6.0*n/(length-1));} break;
                }
            case WINDOW_BLACKMAN_NUTALL :
                {
                    double a0 = 0.3635819;
                    double a1 = 0.4891775;
                    double a2 = 0.1365995;
                    double a3 = 0.0106411;
                    for (int n = 0; n < length; n++){ buffer[n] = a0 - a1*cos(M_PI*2.0*n/(length-1)) + a2*cos(M_PI*4.0*n/(length-1)) - a3*cos(M_PI*6.0*n/(length-1));} break;
                }

            case WINDOW_FLATTOP :
                {
                    double a0 = 1.0;
                    double a1 = 1.93;
                    double a2 = 1.29;
                    double a3 = 0.388;
                    double a4 = 0.032;
                    for (int n = 0; n < length; n++)
                    { buffer[n] =
                        a0 - a1*cos(M_PI*2.0*n/(length-1)) +
                        a2*cos(M_PI*4.0*n/(length-1)) -
                        a3*cos(M_PI*6.0*n/(length-1)) +
                        a4*cos(M_PI*8.0*n/(length-1));
                    } break;
                }
                default: break;
            }
    }

Пример использования:

computeWindow<float>(myFloatWindowBuffer, windowLength, WINDOW_NUTALL);