PhiDjee

I'm using the Hann and Hamming windows for FFT processings.

I have the following C++ code for the Cosine window (works fine!):

for (long k = 0; k < fftFrameSize; k++) {

mWindow[k] = (double) -.5*cos(2.*M_PI*(double)k/(double)fftFrameSize)+.5;

w(n) = 0.42 - 0.8 cos(2*Pi*n/N) + 0.08cos(4*Pi*n/N)

I'd like to test some other windows (like the Sine window) but I don't find the algorithms.

And if you have a C++, it would be wonderful!

I'm using the Hann and Hamming windows for FFT processings.
I have the following C++ code for the Cosine window (works fine!):

 long fftFrameSize = pow(2, fftLog2n);
 switch(mWindowType) {
  case WINDOW_COS:
   for (long k = 0; k < fftFrameSize; k++) {
     mWindow[k] = (double) -.5*cos(2.*M_PI*(double)k/(double)fftFrameSize)+.5;
   }
 break;

For the Blackman, I have:
w(n) = 0.42 - 0.8 cos(2*Pi*n/N) + 0.08cos(4*Pi*n/N)
The window length L = N+1

Does someone could bring me help?
A Max expression would be very cool.
A C code would be perfect.
And if you have a C++, it would be wonderful!

fft-window-type

more like a c expression than a c++ one...unless you're inquiring

about a hanning/window representation of a signal as a

class/inheritance representation? obviously you didn't list your

implementation and definition. it seems to me in your former question

you're addressing what happens in the first element (simply a division

whether this expression is valid granted in the class you've defined,

you're invoking the correct libraries (i.e. ). here's a

somewhat working list of windowing functions:

hann up in there (aka raised cos), which is what you're attempting to invoke...

> I'm using the Hann and Hamming windows for FFT processings.

> I have the following C++ code for the Cosine window (works fine!):

> for (long k = 0; k < fftFrameSize; k++) {

> mWindow[k] = (double) -.5*cos(2.*M_PI*(double)k/(double)fftFrameSize)+.5;

> w(n) = 0.42 - 0.8 cos(2*Pi*n/N) + 0.08cos(4*Pi*n/N)

> I'd like to test some other windows (like the Sine window) but I don't find the algorithms.

> And if you have a C++, it would be wonderful!

more like a c expression than a c++ one...unless you're inquiring
about a hanning/window representation of a signal as a
class/inheritance representation? obviously you didn't list your
implementation and definition. it seems to me in your former question
you're addressing what happens in the first element (simply a division
on 32-bit integers):

whether this expression is valid granted in the class you've defined,
you're invoking the correct libraries (i.e. ). here's a
somewhat working list of windowing functions:

On 2/27/07, Philippe Gruchet  wrote:
>
> Hi,
>
> I'm using the Hann and Hamming windows for FFT processings.
> I have the following C++ code for the Cosine window (works fine!):
>
>  long fftFrameSize = pow(2, fftLog2n);
>  switch(mWindowType) {
>   case WINDOW_COS:
>    for (long k = 0; k < fftFrameSize; k++) {
>      mWindow[k] = (double) -.5*cos(2.*M_PI*(double)k/(double)fftFrameSize)+.5;
>    }
>  break;
>
>
> For the Blackman, I have:
> w(n) = 0.42 - 0.8 cos(2*Pi*n/N) + 0.08cos(4*Pi*n/N)
> The window length L = N+1
>
>
> I'd like to test some other windows (like the Sine window) but I don't find the algorithms.
>
> Does someone could bring me help?
> A Max expression would be very cool.
> A C code would be perfect.
> And if you have a C++, it would be wonderful!
>
> Best regards,
> Philippe
>


This cosine window works very fine here in Xcode.

I already and successfully implemented the Hann and Hamming windows based on the Accelerate.framework.

> here's a somewhat working list of windowing functions:

I was looking for some other windows and this link to Wikipedia is great and very useful, thanks!

From there, I just find what seems the original resource at the MathWorks website:

And I found the sine window in the MaxMSP examples (!?):

[expr (1.1* (sin(($f1/1024. )* (2. * 3.1415926))) - .1)]

As I can't find it anywhere else, is it the right sine window for FFT too?

This cosine window works very fine here in Xcode.
I already and successfully implemented the Hann and Hamming windows based on the Accelerate.framework.

> here's a somewhat working list of windowing functions:
> http://en.wikipedia.org/wiki/Hann_window

I was looking for some other windows and this link to Wikipedia is great and very useful, thanks!
From there, I just find what seems the original resource at the MathWorks website:

in [p ---windo]  ...
[expr (1.1* (sin(($f1/1024. )* (2. * 3.1415926))) - .1)]

I looked at the example patch you're referring to and see that the

sample size is being ramped up into expr (1.1* (sin(($f1/1024. )* (2.

* 3.1415926))) - .1). This is correct, they note that the -.1 is to

just offset the amplitude of the signal so that there's no clipping.

The Sine Window is best known for its use in mp3 compression but

higher resolution Window Types have been experimented with for

different codecs like Ogg Vorbis for better signal representation. The

Sine Window is defined as sin*((3.1415926/2*sample length)(k + 0.5).

What they're really doing in that expression is tweaking the k (where

it's defined as 1.1). The Sine Window takes the entire sample range

(hence 2*512 = 1024 in the denominator) so it seems the creator of the

patch played around with the coefficients to get different subjective

results (see the comment "in listening tests, several classic window

functions (hanning, hamming, squareroot, sinusoid) were tried. the

sine function sounded best. go figure")...that's always an excellent

BTW, I noticed that your coefficient in the second term for the

expansion of the Blackman Window should be 0.5 instead of 0.8, so:

w(n) = 0.42 - 0.5 cos(2*Pi*n/N) + 0.08cos(4*Pi*n/N)

Glad the reference to window types was helpful...

> This cosine window works very fine here in Xcode.

> I already and successfully implemented the Hann and Hamming windows based on the Accelerate.framework.

> > here's a somewhat working list of windowing functions:

> I was looking for some other windows and this link to Wikipedia is great and very useful, thanks!

> >From there, I just find what seems the original resource at the MathWorks website:

> And I found the sine window in the MaxMSP examples (!?):

> [expr (1.1* (sin(($f1/1024. )* (2. * 3.1415926))) - .1)]

> As I can't find it anywhere else, is it the right sine window for FFT too?

I looked at the example patch you're referring to and see that the
sample size is being ramped up into expr (1.1* (sin(($f1/1024. )* (2.
* 3.1415926))) - .1). This is correct, they note that the -.1 is to
just offset the amplitude of the signal so that there's no clipping.

The Sine Window is best known for its use in mp3 compression but
higher resolution Window Types have been experimented with for
different codecs like Ogg Vorbis for better signal representation. The
Sine Window is defined as sin*((3.1415926/2*sample length)(k + 0.5).
What they're really doing in that expression is tweaking the k (where
it's defined as 1.1). The Sine Window takes the entire sample range
(hence 2*512 = 1024 in the denominator) so it seems the creator of the
patch played around with the coefficients to get different subjective
results (see the comment "in listening tests, several classic window
functions (hanning, hamming, squareroot, sinusoid) were tried. the
sine function sounded best. go figure")...that's always an excellent
strategy!

BTW, I noticed that your coefficient in the second term for the
expansion of the Blackman Window should be 0.5 instead of 0.8, so:

On 2/28/07, Philippe Gruchet  wrote:
>
> Hello Brandon,
>
> mWindow[k] = (double) -.5*cos(2.*M_PI*(double)k/(double)fftFrameSize)+.5;
>
> This cosine window works very fine here in Xcode.
> I already and successfully implemented the Hann and Hamming windows based on the Accelerate.framework.
>
> > here's a somewhat working list of windowing functions:
> > http://en.wikipedia.org/wiki/Hann_window
>
> I was looking for some other windows and this link to Wikipedia is great and very useful, thanks!
> >From there, I just find what seems the original resource at the MathWorks website:
>
>
>
> And I found the sine window in the MaxMSP examples (!?):
>
>
> in [p ---windo]  ...
> [expr (1.1* (sin(($f1/1024. )* (2. * 3.1415926))) - .1)]
>
> As I can't find it anywhere else, is it the right sine window for FFT too?
>
> Best,
> Philippe
>


Thank you very much for your explanation about the sine window.

> BTW, I noticed that your coefficient in the second term

> for the expansion of the Blackman Window should be 0.5

Yes, sorry. Just a typo by typing 8 instead of 5, just below ;-)

> Glad the reference to window types was helpful...

I can start my tests and see what works the best.

Thank you very much for your explanation about the sine window.
I keep it in safe place!

> BTW, I noticed that your coefficient in the second term
> for the expansion of the Blackman Window should be 0.5
> instead of 0.8, so:

Oh yes, thanks again!
I can start my tests and see what works the best.

> w(n) = 0.42 - 0.5cos(2*Pi*n/N) + 0.08cos(4*Pi*n/N)

I finally found the double-precision Blackman window inside Xcode/vecLib.framework

Thanks again for the NON-help about that :-(

> For the Blackman, I have:
> w(n) = 0.42 - 0.5cos(2*Pi*n/N) + 0.08cos(4*Pi*n/N)
> The window length L = N+1

extern void 
vDSP_blkman_windowD(
  double *      __vDSP_C,
  vDSP_Length   __vDSP_N,
  int           __vDSP_FLAG)

Thanks again for the NON-help about that :-(
PG


http://mathworld.wolfram.com/ApodizationFunction.html

On Mar 7, 2007, at 2:58 PM, Philippe Gruchet wrote:

>> w(n) = 0.42 - 0.5cos(2*Pi*n/N) + 0.08cos(4*Pi*n/N)

> I finally found the double-precision Blackman window inside Xcode/ 

> Thanks again for the NON-help about that :-(

>
>> For the Blackman, I have:
>> w(n) = 0.42 - 0.5cos(2*Pi*n/N) + 0.08cos(4*Pi*n/N)
>> The window length L = N+1
>
> I finally found the double-precision Blackman window inside Xcode/ 
> vecLib.framework
>
> extern void
> vDSP_blkman_windowD(
>  double *      __vDSP_C,
>  vDSP_Length   __vDSP_N,
>  int           __vDSP_FLAG)
>
> Thanks again for the NON-help about that :-(
> PG


I realise this is 6 years late but in case anyone in future has the same issue, pretty much ever frequently used windowing function can be found at : 

http://en.wikipedia.org/wiki/Window_function

I realise this is 6 years late but in case anyone in future has the same issue, pretty much ever frequently used windowing function can be found at : http://en.wikipedia.org/wiki/Window_function


FFT window type