Podział sygnału na okna

0

Wymyśliłem taki kod, który ma dzielić sygnał na okna i robić "coś" z każdym oknem (DFT, FFT, itp):

class Okna
{
	private:
		double **ModulFT;
	public:
		LiczFT(int, short*, int, int , unsigned long );
	        LiczDFT(double*, int , int)
};
void Okna::LiczFT(int WyborOkna, short *Probki, int PrzesuniecieOkna, int SzerokoscOkna, unsigned long Rozmiar)
{
    //*Probki - wskaznik na tablice probek
    //Rozmiar - rozmiar tablicy probek
    int KoniecOkna;
    double *Tmp = new double[SzerokoscOkna];
    double *Okno = new double[SzerokoscOkna];
    ModulFT = new double*[(Rozmiar - SzerokoscOkna)/PrzesuniecieOkna];
	for(int i = 0,  k = 0; k < (Rozmiar - SzerokoscOkna)/PrzesuniecieOkna; i+=PrzesuniecieOkna,k++)
	{
          //dla każdego okna
	  KoniecOkna = SzerokoscOkna + i;
              for(int c =0; c < SzerokoscOkna;c++)
              {
                   switch(WyborOkna)
                   {    case 0:
                        Tmp[c] = Probki[c] * OknoHamminga(c, Rozmiar);
                        break;
                        case 1:
                        Tmp[c] = Probki[c] * OknoProstokatne(c, Rozmiar);
                        break;
                        case 2:
                        Tmp[c] = Probki[c] * OknoHanna(c, Rozmiar);
                        break;
                        case 3:
                        Tmp[c] = Probki[c] * OknoNuttalla(c, Rozmiar);
                        break;
                  }
              }
			for(int j = i,  z = 0; j < KoniecOkna && z < SzerokoscOkna; j++, z++)
			{
				//dla każdej probki w tym oknie
                               Okno[z] = Probki[j] * Tmp[z];
			}
           ModulFT[k] = new double[SzerokoscOkna];
          //tu wywołuje to co ma liczyć dla danego okna
          LiczDFT(Okno, SzerokoscOkna, k);
        }
delete[] Tmp;
delete[] Okno;
}
void Okna::LiczDFT(double *Probki, int SzerokoscOkna, int k)
{
double sumaDFTre, sumaDFTim;

                for(int l=0 ; l <= SzerokoscOkna - 1; l++)
                {
                   sumaDFTre = 0;
                   sumaDFTim = 0;
                   double Temp = 2* M_PI * l );
                    for(int n = 0; n <= SzerokoscOkna - 1; n++)
                    {
                         sumaDFTre += Probki[n] * (cos(Temp* n/(double)SzerokoscOkna));
                         sumaDFTim += Probki[n] * (-sin(Temp* n/(double)SzerokoscOkna));
                    }
                   ModulFT[k][l] = sqrt(sumaDFTre * sumaDFTre + sumaDFTim * sumaDFTim) / (double)SzerokoscOkna;
                }
}

Moje pytanie jest następujące: Jak zoptymalizować kod aby program był szybszy??(jeśli wywołuję jakąś funkcję dla każdego okna to jest to dosyć wolne rozwiązanie - pętla w pętli w pętli itd.)

0

A nie możesz do tej pętli dodać?

for(int n = 0; n <= SzerokoscOkna - 1; n++)
{
   sumaDFTre += Probki[n] * (cos(Temp* n/(double)SzerokoscOkna)) * okno_ptr(...);
   sumaDFTim += Probki[n] * (-sin(Temp* n/(double)SzerokoscOkna)) * okno_ptr(...);
}

okno_ptr to wskaźnik na wybrany typ okna. A! i pozbądź się dzielenia w Temp* n/(double)SzerokoscOkna.

0

No faktycznie, odejdzie mi dzięki temu jedna pętla i tablica :)
Dziękuje za pomoc, pozdrawiam!!

0

Mała modyfikacja:

double ww = 1.0/double(SzerokoscOkna);
double 2piww = 2* M_PI * ww;

for(int l=0 ; l < SzerokoscOkna ; ++l)
{
	sumaDFTre = 0;
	sumaDFTim = 0;
	
	double Temp = 2piww * l;
	
	for(int n = 0; n < SzerokoscOkna ; ++n)
	{
		double a = n * Temp;
		double s = Probki[n] * okno_ptr(...);
		sumaDFTre += s * (cos(a));
		sumaDFTim += s * (-sin(a));
	}
	
	ModulFT[k][l] = sqrt(sumaDFTre * sumaDFTre + sumaDFTim * sumaDFTim) * ww;
}

1 użytkowników online, w tym zalogowanych: 0, gości: 1