Windowing the little discrete filters we use in image processing is a bit subtle.
What we want from windowing is : you have some theoretical filter like Gauss or Sinc which is non-zero over an
infinite region and you wish to force it to act only on a finite domain.
First of all, for most image filtering operations, you want to use a very small filter. A wider filter
might look like it has a nicer shape, and it may even give better results on smooth parts of the image,
but near edges wide filters reach too much across the edge and produce nasty artifacts, either bad blurring
or ghosting or ringing.
Because of that, I think a half-width of 5 is about the maximum you ever want to use. (in the olden days,
Blinn recommended a half-width of 3, but our typical image resolution is higher now, so I think you can
go up to 5 most of the time, but you will still get artifacts sometimes).
(also for the record I should note that all this linear filtering is rather dinosaur-age technology; of
course you should use some sort of non-linear adaptive filter that is wider in smooth areas and doesn't
cross edges; you could at least use steam-age technology like bilateral filters).
So the issue is that even a half-width of 5 is actually quite narrow.
The "Windows" that you read about are not really meant to be used in such small discrete ranges. You
can go to Wikipedia and read about Hann and Hamming and Blackman and Kaiser and so on, but the thing they
don't really tell you is that using them here is not right. Those windows are only near 1.0 (no change)
very close to the origin. The window needs to be at least 4X wider than the base filter shape, or you
will distort it severely.
Most of the this stuff comes from audio, where you're working on 10000 taps or something.
Say you have a Gaussian with sigma = 1 ; most of the Gaussian is inside a half-width of 2 ; that means your
window should have a half-width of 8. Any smaller window will strongly distort the shape of the base function.
In fact if you just look at the Blackman window : (from Wikipedia)
The window function itself is like a cubic filter. In fact :
Odd Blackman window with half-width of 3 :
const float c_filter[7] = { 0.00660, 0.08050, 0.24284, 0.34014, 0.24284, 0.08050, 0.00660 };
Odd Nutall 3 :
const float c_filter[7] = { 0.00151, 0.05028, 0.24743, 0.40155, 0.24743, 0.05028, 0.00151 };
can be used for filtering by themselves and they're not bad. If you actually want it to work as a *window* , which is just
supposed to make your range finite without severely changing your action, it needs to be much wider.
But we don't want to be wide for many reasons. One is the artifacts mentioned previously, the other is efficiency.
So, I conclude that you basically don't want all these famous windows.
What you really want for our purposes is something that's flatter in the middle and only get steep at
the very edges.
Some windows on 8 taps :
from sharpest to flattest :
//window_nutall :
const float c_filter[8] = { 0.00093, 0.02772, 0.15061, 0.32074, 0.32074, 0.15061, 0.02772, 0.00093 };
//blackman :
const float c_filter[8] = { 0.00435, 0.05122, 0.16511, 0.27932, 0.27932, 0.16511, 0.05122, 0.00435 };
//cos : (aka Hann)
const float c_filter[8] = { 0.00952, 0.07716, 0.17284, 0.24048, 0.24048, 0.17284, 0.07716, 0.00952 };
//window_blackman_sqrt :
const float c_filter[8] = { 0.02689, 0.09221, 0.16556, 0.21534, 0.21534, 0.16556, 0.09221, 0.02689 };
//window_sinc :
const float c_filter[8] = { 0.02939, 0.09933, 0.16555, 0.20572, 0.20572, 0.16555, 0.09933, 0.02939 };
//sin :
const float c_filter[8] = { 0.03806, 0.10839, 0.16221, 0.19134, 0.19134, 0.16221, 0.10839, 0.03806 };
I found the sqrt of the blackman window is pretty close to a sinc window. But really if you use any
of these on a filter which is 8-wide, they are severely distorting it.
You can get flatter windows in various ways; by distorting the above for example (stretching out their
middle part). Or you could use a parameterized window like Kaiser :
Kaiser : larger alpha = sharper
// alpha = infinite is a delta function
//window_kaiser_6 :
const float c_filter[8] = { 0.01678, 0.07635, 0.16770, 0.23917, 0.23917, 0.16770, 0.07635, 0.01678 };
//window_kaiser_5 :
const float c_filter[8] = { 0.02603, 0.08738, 0.16553, 0.22106, 0.22106, 0.16553, 0.08738, 0.02603 };
//window_kaiser_4 :
const float c_filter[8] = { 0.03985, 0.09850, 0.16072, 0.20093, 0.20093, 0.16072, 0.09850, 0.03985 };
//window_kaiser_3 :
const float c_filter[8] = { 0.05972, 0.10889, 0.15276, 0.17863, 0.17863, 0.15276, 0.10889, 0.05972 };
// alpha = 0 is flat line
Kaiser-Bessel-Derived :
//kbd 6 :
const float c_filter[8] = { 0.01763, 0.10200, 0.17692, 0.20345, 0.20345, 0.17692, 0.10200, 0.01763 };
//kbd 5 :
const float c_filter[8] = { 0.02601, 0.10421, 0.17112, 0.19866, 0.19866, 0.17112, 0.10421, 0.02601 };
//kbd 4 :
const float c_filter[8] = { 0.03724, 0.10637, 0.16427, 0.19213, 0.19213, 0.16427, 0.10637, 0.03724 };
//kbd 3 :
const float c_filter[8] = { 0.05099, 0.10874, 0.15658, 0.18369, 0.18369, 0.15658, 0.10874, 0.05099 };
these are interesting, but they're too expensive to evaluate at arbitrary float positions; you can only use
them to fill out small discrete filters. So that's mildly annoying.
There's something else about windowing that I should clear up as well :
Where do you put the ends of the window?
Say I have a discrete filter of 8 taps. Obviously I don't put the ends of the window right on my last taps,
because the ends of the window are zeros, so they would just make my last taps zero, and I may as well use
a 6-tap filter in that case.
So I want to put the end points somewhere past the ends of my discrete filter range. In all the above examples
in this post, I have put the end points 0.5 taps past each end of the discrete range. That means the window goes to
zero half way between the last tap inside the window and the first tap outside the window. That's on the left :
On the right is another option, which is the window could go to zero 1.0 taps past the end of the discrete range -
that is, it goes to zero exactly on the next taps. In both cases this produces a finite window of the desired size,
but it's slightly different.
For a four tap filter, the left-side way uses a window that is 4.0 wide ; the right side uses a window that is 5.0 wide.
If you image the pixels as squares, the left-side way only overlaps the 4 pixels cenetered on the filter taps; the
right side way actually partially overlaps the next pixels on each side, but doesn't quite reach their centers, thus
has zero value when sampled at their center.
I don't know of any reason to strongly prefer one or the other. I'm using the 0.5 window extension in my code.
Let me show some concrete examples, then we'll talk about them briefly :
//filter-windower-halfwidth :
//gauss-unity-5 :
const float c_filter[11] = { 0.00103, 0.00760, 0.03600, 0.10936, 0.21301, 0.26601, 0.21301, 0.10936, 0.03600, 0.00760, 0.00103 };
//gauss-sinc-5 :
const float c_filter[11] = { 0.00011, 0.00282, 0.02336, 0.09782, 0.22648, 0.29882, 0.22648, 0.09782, 0.02336, 0.00282, 0.00011 };
//gauss-blackman-5 :
const float c_filter[11] = { 0.00001, 0.00079, 0.01248, 0.08015, 0.23713, 0.33889, 0.23713, 0.08015, 0.01248, 0.00079, 0.00001 };
//gauss-blackman-7 :
const float c_filter[15] = { 0.00000, 0.00000, 0.00015, 0.00254, 0.02117, 0.09413, 0.22858, 0.30685, 0.22858, 0.09413, 0.02117, 0.00254, 0.00015, 0.00000, 0.00000 };
//gauss-blackman-7 , ends cut :
const float c_filter[11] = { 0.00015, 0.00254, 0.02117, 0.09413, 0.22858, 0.30685, 0.22858, 0.09413, 0.02117, 0.00254, 0.00015 };
//gauss-blackman-13, ends cut :
const float c_filter[11] = { 0.00061, 0.00555, 0.03085, 0.10493, 0.21854, 0.27906, 0.21854, 0.10493, 0.03085, 0.00555, 0.00061 };
1. The gaussian, even though technically infinite, goes to zero so fast that you really don't need to window it *at all*. All
the windows distort the shape quite a bit. (technically this is a rectangular window, but the hard cut-off at the edge is
invisible)
2. Windows distorting the shape is not necessarily a bad thing! Gauss windowed by Sinc (for example) is actually a very nice filter,
somewhat sharper than the true gaussian. Obviously you can get the same thing by playing with the sdev of the gaussian, but if you
don't have a parameterized filter you can use the window as a way to adjust the compactness of the filter.
3. Cutting off the ends of a filter is not the same as using a smaller window! For example if you made gauss-blackman-7 you might say
"hey the ends are really close to zero, it's dumb to run a filter over an image with zero taps at the end, I'll just use a width of 5!".
But gauss-blackman-5 is very different! Making the window range smaller changes the shape.
4. If you want the original filter shape to not be damaged too much, you have to use wider windows for sharper window functions.
Even blackman at a half-width of 13 (full width of 27) is distorting the gaussian a lot.
(A is 11 wide because I used an 11x11 matrix; in general it's infinitely wide, but gets smaller as you go out)
The synthesis cubic is piece-wise cubic and defined over four unit intervals from [-2,2]
The combined filter is piece-wise cubic; each unit interval is a linear combo of the 4 parts of synthesis
mitchell1 analysis :
const float c_filter[11] = { -0.00000, 0.00002, -0.00028, 0.00446, -0.07115, 1.13389, -0.07115, 0.00446, -0.00028, 0.00002, -0.00000 };
chart :
