예제 #1
0
        public float[] FrequencyFiltration(int windowLength, int filterLength, double cutFreq, int windowHopSize, int windowType, string filterType)
        {
            // rozmiar transformacji DFT
            int n = SoundUtil.GetExpandedPow2(windowLength + filterLength - 1);

            // d³ugoœæ sygna³u wynikowego
            int size = dataNormalized.Length + n - windowLength;

            float[] result = new float[size];

            // okna
            double[][]  windows        = new double[size / windowHopSize][];
            Complex[][] windowsComplex = new Complex[size / windowHopSize][];

            for (int i = 0; i < windows.Length; i++)
            {
                windows[i]        = new double[n];
                windowsComplex[i] = new Complex[n];
            }

            // wyliczenie wspó³czynników okna
            double[] windowFactors = SoundUtil.Factors(windowType, windowLength);

            for (int i = 0; i < windows.Length; i++)
            {
                // wymno¿enie wspó³czynników okna przez wartoœci sygna³u
                for (int j = 0; j < windowLength; j++)
                {
                    if (i * windowHopSize + j < dataNormalized.Length)
                    {
                        windows[i][j] = windowFactors[j] * dataNormalized[i * windowHopSize + j];
                    }
                    else
                    {
                        windows[i][j] = 0;
                    }
                }

                // uzupe³nienie pozosta³ych miejsc zerami
                for (int j = windowLength; j < n; j++)
                {
                    windows[i][j] = 0;
                }
            }

            // wyliczenie wspó³czynników okna
            double[] windowFilterFactors = SoundUtil.Factors(windowType, filterLength);

            // wyliczenie wspó³czynników filtru
            double[] filterFactors = SoundUtil.LowPassFilterFactors(cutFreq, sampleRate, filterLength);
            double[] filtered      = new double[n];

            // wymno¿enie wspó³czynników okna i filtru
            for (int i = 0; i < filterLength; i++)
            {
                filtered[i] = windowFilterFactors[i] * filterFactors[i];
            }

            // uzupe³nienie pozosta³ych miejsc zerami
            for (int i = filterLength; i < n; i++)
            {
                filtered[i] = 0;
            }

            if (filterType == "notCasual")
            {
                // dla filtra nieprzyczynowego przesuwamy po³owê wartoœci filtra na jego koniec
                int shiftNumberFilter = (filterLength - 1) / 2;
                IEnumerable <double> shiftedFilter = filtered.Take(shiftNumberFilter);
                List <double>        filteredTemp  = filtered.Skip(shiftNumberFilter).ToList();
                filteredTemp.AddRange(shiftedFilter);
                filtered = filteredTemp.ToArray();
            }

            // zmiana przefiltrowanych wspó³czynników na liczby zespolone i wykonanie FFT
            Complex[] complexSound    = SoundUtil.SignalToComplex(filtered);
            Complex[] filteredComplex = SoundUtil.FFT(complexSound);

            for (int i = 0; i < windows.Length; i++)
            {
                // zmiana wartoœci sygna³u okna na liczby zespolone i wykonanie FFT
                windowsComplex[i] = SoundUtil.FFT(SoundUtil.SignalToComplex(windows[i]));

                // wymno¿enie wartoœci sygna³u okna ze wspó³czynnikami
                for (int j = 0; j < windowsComplex[i].Length; j++)
                {
                    windowsComplex[i][j] *= filteredComplex[j];
                }

                // wykonanie IFFT na oknie i zmiana na sygna³ wyjœciowy
                windows[i] = SoundUtil.SignalFromComplex(SoundUtil.IFFT(windowsComplex[i]));
            }

            // dodanie wyniku do sygna³u wyjœciowego
            for (int i = 0; i < windows.Length; i++)
            {
                for (int j = 0; j < windows[i].Length; j++)
                {
                    if (i * windowHopSize + j < dataNormalized.Length)
                    {
                        result[i * windowHopSize + j] += (float)windows[i][j];
                    }
                }
            }

            return(result);
        }
예제 #2
0
        public List <int> Cepstrum()
        {
            int        chunkSize   = this.chunkSize;
            List <int> frequencies = new List <int>();

            float[][] parts;

            // ustawiamy chunkSize jako potêge 2 dla póŸniejszego FFT
            chunkSize = SoundUtil.MakePowerOf2(chunkSize);
            // dzielimy pobrane próbki dŸwiêku na fragmenty
            parts = SoundUtil.ChunkArrayPowerOf2(dataNormalized, chunkSize);

            foreach (float[] buffer in parts)
            {
                // konwertujemy dane wejœciowe spróbkowanego sygna³u na postaæ zespolon¹
                Complex[] complexSound = SoundUtil.SignalToComplex(buffer);

                // przepuszczamy dane przez okno Hamminga
                Complex[] complexWindows = SoundUtil.HammingWindow(complexSound);

                // pierwsze FFT
                Complex[] fftComplex = SoundUtil.FFT(complexWindows);

                // zapamiêtujemy wynik pierwszego FFT w celu wyœwietlenia wykresu
                fftDataForSpectrumChart = new Complex[fftComplex.Length];
                fftComplex.CopyTo(fftDataForSpectrumChart, 0);

                // przepuszczamy modu³ widma przez logarytm
                for (int i = 0; i < fftComplex.Length; ++i)
                {
                    fftComplex[i] = new Complex(10.0f * (float)Math.Log10(fftComplex[i].Modulus() + 1), 0);
                }

                // drugie FFT, w celu uzyskania cepstrum
                fftComplex = SoundUtil.FFT(fftComplex);

                // zapamiêtujemy wynik cepstrum w celu wyœwietlenia wykresu
                cepstrum = new Complex[fftComplex.Length];
                fftComplex.CopyTo(cepstrum, 0);

                // bierzemy 1/4 wyników bo po ka¿dym FFT po³owa wyników jest taka sama a FFT wykonujemy 2 razy
                fftComplex = fftComplex.Take(fftComplex.Length / 4).ToArray();

                // modu³y wartoœci z FFT
                double[] dataArray = new double[chunkSize];

                // zapisanie modu³ów wartoœci z FFT do pierwszego wymiaru bufora
                for (int i = 0; i < fftComplex.Length; ++i)
                {
                    dataArray[i] = fftComplex[i].Modulus();
                }

                List <int> localMaxIndexes = new List <int>();
                //promieñ, zakres w którym badamy czy wartoœæ jest maksimum lokalnym
                int range = 10;

                for (int i = range; i < dataArray.Length - range; i++)
                {
                    int biggerValue = 0;
                    // badamy otoczenie punktu
                    for (int j = i - range; j < i + range; ++j)
                    {
                        // je¿eli bie¿¹ca wartoœæ z otoczenia jest mniejsza od punktu,
                        // który sprawdzamy wtedy zliczamy je
                        if (dataArray[j] <= dataArray[i] && i != j)
                        {
                            biggerValue++;
                        }
                    }

                    // jeœli w otoczeniu nie ma mniejszych wartoœci to
                    // dodajemy numer wartoœci do tablicy lokalnych maksimów
                    if (biggerValue == (range * 2) - 1)
                    {
                        localMaxIndexes.Add(i);
                    }
                }

                // odrzucanie wysokich wartoœci ale nie stromych
                // musza opadaæ w obu kierunkach
                for (int index = 0; index < localMaxIndexes.Count;)
                {
                    int i = localMaxIndexes[index], leftIndexOffset = 0, rightIndexOffset = 0;

                    // badamy lewe zbocze w poszukiwaniu wartoœci najni¿szej wartoœci,
                    // w której zmienia siê omnotonicznoœæ
                    while ((i - leftIndexOffset - 1) >= 0)
                    {
                        if ((dataArray[i - leftIndexOffset - 1] <= dataArray[i - leftIndexOffset]))
                        {
                            ++leftIndexOffset;
                        }
                        else
                        {
                            break;
                        }
                    }

                    // badamy prawe zbocze w poszukiwaniu najwy¿szej wartoœci
                    // w której zmienia siê omnotonicznoœæ
                    while ((i + rightIndexOffset + 1) < dataArray.Length)
                    {
                        if ((dataArray[i + rightIndexOffset + 1] <= dataArray[i + rightIndexOffset]))
                        {
                            ++rightIndexOffset;
                        }
                        else
                        {
                            break;
                        }
                    }

                    // progowanie co do najwiêkszego peaku
                    // wybieramy punktu o wiêkszej wartoœci spoœród znalezionych po lewej i prawej stronoe
                    double maxmin = Math.Max(dataArray[i - leftIndexOffset], dataArray[i + rightIndexOffset]);

                    // porównujemy wartoœæ maksymaln¹ minimów z wczeœniej znalezionych punktów i porówujemy je z lokalnym maksem
                    // je¿eli najwiêksza wartoœæ minimalna jest wiêksza od bie¿¹co rozpatrywanego poziomu maksimum
                    if (maxmin > dataArray[i] * 0.2)
                    {
                        // wtedy usuwamy to maksimum
                        localMaxIndexes.RemoveAt(index);
                    }
                    else
                    {
                        index++;
                    }
                }

                // szukanie pozycji maksymalnej wartoœci z listy lokalnych maksimów
                int max_ind = SoundUtil.MaxFromLocalMaxList(localMaxIndexes, dataArray);

                // przeszukanie listy maksimów w celu usuniêcia tych znajduj¹cych siê ponad progiem
                for (int index = 0; index < localMaxIndexes.Count;)
                {
                    // je¿eli bie¿¹ca wartoœæ lokalnego maksimum z listy jest ponad progiem znalezionej wartoœci maksymalnej na liœcie
                    if (dataArray[localMaxIndexes[index]] > dataArray[max_ind] * 0.4)
                    {
                        index++;
                    }
                    else
                    {
                        // w przeciwnym wypadku usuwamy maksimum z listy
                        localMaxIndexes.RemoveAt(index);
                    }
                }

                // zmienne maj¹ce zapamiêtaæ dwa indeksy z listy maksimów
                int max_b, max_a;

                // szukanie pozycji maksymalnej wartoœci z listy lokalnych maksimów
                max_b = SoundUtil.MaxFromLocalMaxList(localMaxIndexes, dataArray);

                int a = 0, b = 0;
                while (localMaxIndexes.Count > 1)
                {
                    // usuwamy wczeœniej zapamiêtane maksimum z listy
                    localMaxIndexes.Remove(max_b);

                    // szukanie pozycji maksymalnej wartoœci z listy lokalnych maksimów
                    max_a = SoundUtil.MaxFromLocalMaxList(localMaxIndexes, dataArray);

                    // zapamiêtanie wczeœniej pozycji wczeœniej usuniêtego maksimum
                    // i tego znaleziono po nim
                    a = max_a; b = max_b;

                    // je¿eli indeksy maksimów nie s¹ w kolejnoœci rosn¹æ zamieniamy je
                    if (a > b)
                    {
                        int tmp = a;
                        a = b;
                        b = tmp;
                    }

                    for (int i = 0; i < localMaxIndexes.Count;)
                    {
                        int num = localMaxIndexes[i];

                        // je¿eli indeks bie¿¹cego maksimum z listy jest poza przedzia³em
                        // wyznaczonym przez poprzednie zapisane maksima
                        if (num < a || num > b)
                        {
                            // usuwamy indeks maksimum z listy
                            localMaxIndexes.RemoveAt(i);
                        }
                        else
                        {
                            i++;
                        }
                    }

                    // najstarszey zapamiêtany indeks maksimum zastêpujemy kolejnym maksimmum po nim
                    max_b = max_a;
                }

                // wyliczamy ró¿nicê miêdzy znalezionymi indeksami maksimów
                max_ind = Math.Abs(b - a);

                // je¿eli lokalnym maksimum z listy jest pierwszy indeks i jedyny indeks na liœcie
                if (max_ind == 0 && localMaxIndexes.Count == 1)
                {
                    max_ind = localMaxIndexes[0];
                }

                // czêstotliwoœæ podstawowa wyliczana jest jako iloraz czêstotliwoœci próbkowania
                // i pozycji maksimum (która tak naprawde wyznacza okres)
                int frequency = (int)(sampleRate / (double)max_ind);
                frequencies.Add(frequency);
            }

            return(frequencies);
        }