You can subscribe to this list here.
2001 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}
(81) 
_{Oct}
(41) 
_{Nov}
(55) 
_{Dec}
(14) 

2002 
_{Jan}
(34) 
_{Feb}
(3) 
_{Mar}
(16) 
_{Apr}
(5) 
_{May}
(10) 
_{Jun}
(13) 
_{Jul}
(24) 
_{Aug}
(14) 
_{Sep}
(14) 
_{Oct}
(9) 
_{Nov}
(10) 
_{Dec}
(16) 
2003 
_{Jan}
(25) 
_{Feb}
(59) 
_{Mar}
(9) 
_{Apr}
(21) 
_{May}
(54) 
_{Jun}
(4) 
_{Jul}
(16) 
_{Aug}
(19) 
_{Sep}
(19) 
_{Oct}
(15) 
_{Nov}
(13) 
_{Dec}
(22) 
2004 
_{Jan}
(19) 
_{Feb}
(8) 
_{Mar}
(20) 
_{Apr}
(16) 
_{May}
(13) 
_{Jun}
(18) 
_{Jul}
(18) 
_{Aug}
(14) 
_{Sep}
(24) 
_{Oct}
(47) 
_{Nov}
(20) 
_{Dec}
(10) 
2005 
_{Jan}
(23) 
_{Feb}
(31) 
_{Mar}
(11) 
_{Apr}
(29) 
_{May}
(18) 
_{Jun}
(7) 
_{Jul}
(11) 
_{Aug}
(12) 
_{Sep}
(8) 
_{Oct}
(4) 
_{Nov}
(11) 
_{Dec}
(7) 
2006 
_{Jan}
(7) 
_{Feb}
(8) 
_{Mar}
(15) 
_{Apr}
(3) 
_{May}
(8) 
_{Jun}
(25) 
_{Jul}
(19) 
_{Aug}
(3) 
_{Sep}
(17) 
_{Oct}
(27) 
_{Nov}
(24) 
_{Dec}
(9) 
2007 
_{Jan}
(6) 
_{Feb}
(43) 
_{Mar}
(33) 
_{Apr}
(8) 
_{May}
(20) 
_{Jun}
(11) 
_{Jul}
(7) 
_{Aug}
(8) 
_{Sep}
(11) 
_{Oct}
(22) 
_{Nov}
(15) 
_{Dec}
(18) 
2008 
_{Jan}
(14) 
_{Feb}
(6) 
_{Mar}
(6) 
_{Apr}
(37) 
_{May}
(13) 
_{Jun}
(17) 
_{Jul}
(22) 
_{Aug}
(16) 
_{Sep}
(14) 
_{Oct}
(16) 
_{Nov}
(29) 
_{Dec}
(13) 
2009 
_{Jan}
(7) 
_{Feb}
(25) 
_{Mar}
(38) 
_{Apr}
(57) 
_{May}
(12) 
_{Jun}
(32) 
_{Jul}
(32) 
_{Aug}
(35) 
_{Sep}
(10) 
_{Oct}
(28) 
_{Nov}
(16) 
_{Dec}
(49) 
2010 
_{Jan}
(57) 
_{Feb}
(37) 
_{Mar}
(22) 
_{Apr}
(15) 
_{May}
(45) 
_{Jun}
(25) 
_{Jul}
(32) 
_{Aug}
(7) 
_{Sep}
(13) 
_{Oct}
(2) 
_{Nov}
(11) 
_{Dec}
(28) 
2011 
_{Jan}
(35) 
_{Feb}
(39) 
_{Mar}

_{Apr}
(25) 
_{May}
(32) 
_{Jun}
(17) 
_{Jul}
(29) 
_{Aug}
(10) 
_{Sep}
(26) 
_{Oct}
(9) 
_{Nov}
(28) 
_{Dec}
(4) 
2012 
_{Jan}
(24) 
_{Feb}
(47) 
_{Mar}
(4) 
_{Apr}
(8) 
_{May}
(9) 
_{Jun}
(6) 
_{Jul}
(4) 
_{Aug}
(1) 
_{Sep}
(4) 
_{Oct}
(28) 
_{Nov}
(2) 
_{Dec}
(2) 
2013 
_{Jan}
(11) 
_{Feb}
(3) 
_{Mar}
(4) 
_{Apr}
(38) 
_{May}
(15) 
_{Jun}
(11) 
_{Jul}
(15) 
_{Aug}
(2) 
_{Sep}
(2) 
_{Oct}
(4) 
_{Nov}
(3) 
_{Dec}
(14) 
2014 
_{Jan}
(24) 
_{Feb}
(31) 
_{Mar}
(28) 
_{Apr}
(16) 
_{May}
(7) 
_{Jun}
(6) 
_{Jul}
(1) 
_{Aug}
(10) 
_{Sep}
(10) 
_{Oct}
(2) 
_{Nov}

_{Dec}

2015 
_{Jan}
(6) 
_{Feb}
(5) 
_{Mar}
(2) 
_{Apr}
(1) 
_{May}

_{Jun}

_{Jul}
(1) 
_{Aug}
(1) 
_{Sep}
(2) 
_{Oct}
(1) 
_{Nov}
(19) 
_{Dec}

2016 
_{Jan}
(6) 
_{Feb}
(1) 
_{Mar}
(7) 
_{Apr}

_{May}
(6) 
_{Jun}

_{Jul}
(3) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 





1

2

3
(2) 
4
(2) 
5

6

7

8

9

10

11

12
(11) 
13
(7) 
14
(3) 
15

16

17

18

19
(1) 
20

21

22

23

24

25

26

27

28

29

30


From: Nicolas Rougier <Nicolas.R<ougier@in...>  20110903 21:20:15

Thanks for the explanation. In fact, in the "real" implementation, I also used a texture lookup to store kernel values (see GPU gems 24) and read them when needed. I was trying to normalize my kernel before storing it but your code is easier to use. For visvis, you might be interested in the different weight functions (I translated those of the antigrain library that are used in matplotlib): http://code.google.com/p/glumpy/source/browse/glumpy/image/filter.py http://code.google.com/p/glumpy/source/browse/glumpy/image/filter.vert http://code.google.com/p/glumpy/source/browse/glumpy/image/filter.frag Thanks again, you made my day ! Nicolas On Sep 3, 2011, at 22:27 , Almar Klein wrote: > Hi, > > I've been playing with gaussian texture filtering using shaders and I obtained a strange "grid" effect on a completely uniform texture. Since all fragments get the same processing and same neighbouring values,I wonder if the grid is the result of some kind of artifact with floating points or the way texture coordinates are interpolated. Or I missed something completely obvious… > > The Gaussian kernel is in theory infinite. Of course you need to cut it off somewhere, but you should normalize the kernel such that its sum is 1.0. I'm guessing that the fact that your kernel is asymetric does not help either. > > The code below fixes the pattern: > > vec4 > filter( float x, vec4 c0, vec4 c1, vec4 c2, vec4 c3 ) > { > float w; > > w = gaussian(x+1.0); // h.x; > float w_sum = w; > vec4 r = c0 * w; > > w = gaussian(x+0.0); // h.y; > w_sum += w; > r += c1 * w; > > w = gaussian(1.0x); // h.z; > w_sum += w; > r += c2 * w; > > w = gaussian(2.0x); // h.w; > w_sum += w; > r += c3 * w; > > return r/w_sum; > } > > > Also a suggestion. I'm doing something similar in visvis to antialias 2D images. I also use a vec4 to represent the kernel, but I make use of the fact that the Gaussian kernel is symetric: kernel[0] is the center element, and kernel[1] to kernel[3] are the 3 elements on each side of the center. This way I get a kernel of effectively 7 elements. Further, I calculate (and normalize) the kernel beforehand in Python, and pass it as a uniform vec4. This way, it does not have to be calculated for each pixel. I'm not sure how significant this is for the speed, but there is a costly exp call in there ... > > Regards, > Almar > > 
From: Almar Klein <almar.klein@gm...>  20110903 20:27:25

Hi, > I've been playing with gaussian texture filtering using shaders and I > obtained a strange "grid" effect on a completely uniform texture. Since all > fragments get the same processing and same neighbouring values,I wonder if > the grid is the result of some kind of artifact with floating points or the > way texture coordinates are interpolated. Or I missed something completely > obvious… > The Gaussian kernel is in theory infinite. Of course you need to cut it off somewhere, but you should normalize the kernel such that its sum is 1.0. I'm guessing that the fact that your kernel is asymetric does not help either. The code below fixes the pattern: vec4 filter( float x, vec4 c0, vec4 c1, vec4 c2, vec4 c3 ) { float w; w = gaussian(x+1.0); // h.x; float w_sum = w; vec4 r = c0 * w; w = gaussian(x+0.0); // h.y; w_sum += w; r += c1 * w; w = gaussian(1.0x); // h.z; w_sum += w; r += c2 * w; w = gaussian(2.0x); // h.w; w_sum += w; r += c3 * w; return r/w_sum; } Also a suggestion. I'm doing something similar in visvis to antialias 2D images. I also use a vec4 to represent the kernel, but I make use of the fact that the Gaussian kernel is symetric: kernel[0] is the center element, and kernel[1] to kernel[3] are the 3 elements on each side of the center. This way I get a kernel of effectively 7 elements. Further, I calculate (and normalize) the kernel beforehand in Python, and pass it as a uniform vec4. This way, it does not have to be calculated for each pixel. I'm not sure how significant this is for the speed, but there is a costly exp call in there ... Regards, Almar 