# Window Presum FFT

Started by January 28, 2010
```Hi everyone,
I would really appreciate if someone answers to my question.

http://archive.chipcenter.com/dsp/DSP000315F1.html

I am trying to understand the idea. I did a quick matlab simulation on
this subject, and it is behaving as it's been explained in this article.
So basically, let's say, if we have a hamming window of size 512, which
translates to some passband frequency in the frequency domain.
If, I wan't to make the passband of may hamming window narrower (let's say
by a factor of 2), then this can be accomplished by making the size of my
hamming window to be 1024, and then take an 1024-point FFT of this new size
hamming window.
The alternative, and more practical approach, is the Winodow Presum FFT,
in which, similarly, we double the length of our hamming winodw. But now,
instead of taking a 1024 FFT, we devide our hamming winodw into 2 chunks:
samples ranging from [1:512]
sapmles ranging from [513:1024]
and then "Sum" these two regions up together.
and Now we take the 512-point FFT of the "Sum", which ultimately is almost
the same thing as taking the 1024-point FFT of our 1024-size hamming
window.
I hope that I addressed my question clearly. As, I said, I ran a quick
matlab simulation, and it appears to be working.
I am just trying to undertand the reasoning behind this, and why it works
the way it works??
Any explanation? I would appreciate if someone can explain what is, in
fact, happening.
I really cannot see too much connection between why breaking up the time
window to two lenghts and adding those will result in narrowing the
passband of our window!!!!
thanks, and I would appreciate in advance.

Rudy

```
```On Jan 28, 7:57&#2013266080;am, "rudykeram" <rudyke...@yahoo.com> wrote:
> Hi everyone,
> I would really appreciate if someone answers to my question.
>
> http://archive.chipcenter.com/dsp/DSP000315F1.html
>
> I am trying to understand the idea. I did a quick matlab simulation on
> this subject, and it is behaving as it's been explained in this article.
> So basically, let's say, if we have a hamming window of size 512, which
> translates to some passband frequency in the frequency domain.
> If, I wan't to make the passband of may hamming window narrower (let's say
> by a factor of 2), then this can be accomplished by making the size of my
> hamming window to be 1024, and then take an 1024-point FFT of this new size
> hamming window.
> The alternative, and more practical approach, is the Winodow Presum FFT,
> in which, similarly, we double the length of our hamming winodw. But now,
> instead of taking a 1024 FFT, we devide our hamming winodw into 2 chunks:
> samples ranging from [1:512]
> sapmles ranging from [513:1024]
> and then "Sum" these two regions up together.
> and Now we take the 512-point FFT of the "Sum", which ultimately is almost
> the same thing as taking the 1024-point FFT of our 1024-size hamming
> window.
> I hope that I addressed my question clearly. As, I said, I ran a quick
> matlab simulation, and it appears to be working.
> I am just trying to undertand the reasoning behind this, and why it works
> the way it works??
> Any explanation? I would appreciate if someone can explain what is, in
> fact, happening.
> I really cannot see too much connection between why breaking up the time
> window to two lenghts and adding those will result in narrowing the
> passband of our window!!!!
> thanks, and I would appreciate in advance.
>
> Rudy

Simple explanation of window presum, also known as Windowed Overlap-
Add (WOLA), and I believe I've also heard it called a polyphase FFT:

- A longer window allows you more freedom (i.e. coefficients) to
design the frequency response that you want. You can then have
resulting FFT bins that have very sharp cutoffs in magnitude with
little overlap, reducing spectral leakage. Typical window lengths are
2x or 4x the desired FFT length (dictated by desired bin resolution
bandwidth in the final result). you design the window as a lowpass
filter whose bandwidth corresponds to the bin bandwidth that you want

- You take that longer window and pointwise-multiply a chunk of your
data by it. This gives you a windowed dataset that is a multiple of
the desired FFT length.

- You then cut the longer dataset into the 2 or 4 FFT-sized chunks
that it contains, stack them up, and add them. This is aliasing in the
time domain. Just as decimation in the time domain gives you aliasing
in the frequency domain, aliasing in the time domain gives you
decimation in the frequency domain. You need to decimate in this way
because your window is designed for the bin spacing dictated by your
FFT length. If you didn't perform this step, you would end up with 2x
or 4x the number of bins that you want with smaller spacing between
them, giving you a lot of overlap.

- The resulting FFT-sized block then goes into your FFT. The resulting
frequency response of each bin is dictated by the window you designed.

- Assuming you have more data to process, you would typically take
some stride through the data (I've seen the stride length be Nfft/2,
Nfft, or even larger, depending upon what you're trying to accomplish;
if you're going to use a synthesis filterbank to reconstruct the
signal later, you can't stride too far) and repeat the process to get
a new STFT result.

Jason
```
```>On Jan 28, 7:57=A0am, "rudykeram" <rudyke...@yahoo.com> wrote:
>> Hi everyone,
>> I would really appreciate if someone answers to my question.
>>
>> http://archive.chipcenter.com/dsp/DSP000315F1.html
>>
>> I am trying to understand the idea. I did a quick matlab simulation on
>> this subject, and it is behaving as it's been explained in this
article.
>> So basically, let's say, if we have a hamming window of size 512,
which
>> translates to some passband frequency in the frequency domain.
>> If, I wan't to make the passband of may hamming window narrower (let's
sa=
>y
>> by a factor of 2), then this can be accomplished by making the size of
my
>> hamming window to be 1024, and then take an 1024-point FFT of this new
si=
>ze
>> hamming window.
>> The alternative, and more practical approach, is the Winodow Presum
FFT,
>> in which, similarly, we double the length of our hamming winodw. But
now,
>> instead of taking a 1024 FFT, we devide our hamming winodw into 2
chunks:
>> samples ranging from [1:512]
>> sapmles ranging from [513:1024]
>> and then "Sum" these two regions up together.
>> and Now we take the 512-point FFT of the "Sum", which ultimately is
almos=
>t
>> the same thing as taking the 1024-point FFT of our 1024-size hamming
>> window.
>> I hope that I addressed my question clearly. As, I said, I ran a quick
>> matlab simulation, and it appears to be working.
>> I am just trying to undertand the reasoning behind this, and why it
works
>> the way it works??
>> Any explanation? I would appreciate if someone can explain what is, in
>> fact, happening.
>> I really cannot see too much connection between why breaking up the
time
>> window to two lenghts and adding those will result in narrowing the
>> passband of our window!!!!
>> thanks, and I would appreciate in advance.
>>
>> Rudy
>
>Simple explanation of window presum, also known as Windowed Overlap-
>Add (WOLA), and I believe I've also heard it called a polyphase FFT:
>
>- A longer window allows you more freedom (i.e. coefficients) to
>design the frequency response that you want. You can then have
>resulting FFT bins that have very sharp cutoffs in magnitude with
>little overlap, reducing spectral leakage. Typical window lengths are
>2x or 4x the desired FFT length (dictated by desired bin resolution
>bandwidth in the final result). you design the window as a lowpass
>filter whose bandwidth corresponds to the bin bandwidth that you want
>
>- You take that longer window and pointwise-multiply a chunk of your
>data by it. This gives you a windowed dataset that is a multiple of
>the desired FFT length.
>
>- You then cut the longer dataset into the 2 or 4 FFT-sized chunks
>that it contains, stack them up, and add them. This is aliasing in the
>time domain. Just as decimation in the time domain gives you aliasing
>in the frequency domain, aliasing in the time domain gives you
>decimation in the frequency domain. You need to decimate in this way
>because your window is designed for the bin spacing dictated by your
>FFT length. If you didn't perform this step, you would end up with 2x
>or 4x the number of bins that you want with smaller spacing between
>them, giving you a lot of overlap.
>
>- The resulting FFT-sized block then goes into your FFT. The resulting
>frequency response of each bin is dictated by the window you designed.
>
>- Assuming you have more data to process, you would typically take
>some stride through the data (I've seen the stride length be Nfft/2,
>Nfft, or even larger, depending upon what you're trying to accomplish;
>if you're going to use a synthesis filterbank to reconstruct the
>signal later, you can't stride too far) and repeat the process to get
>a new STFT result.
>
>Jason
>

Hi Jason,
Thanks a lot for your detailed answer. It makes a lot of sense. Now I
completely understand. If I view this the way that you explained with time
domain aliasing, it makes sense.

thank you very much

Rudy

```
```On Jan 28, 4:57&#2013266080;am, "rudykeram" <rudyke...@yahoo.com> wrote:
> Hi everyone,
> I would really appreciate if someone answers to my question.
> I was trying to learn about presum windowing, ...
>

> Rudy

There is a PhD thesis on the topic out of BYU:
Time Aliasing Methods of Spectrum Estimation
Dahl, Jason F 1967-
http://contentdm.lib.byu.edu/ETD/image/etd157.pdf

Dale B. Dalrymple
```
```And let's not forget:

http://www.embedded.com/design/embeddeddsp/208800863?_requestid=336150

Dale B. Dalrymple

```