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

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}
(2) 

2006 
_{Jan}
(36) 
_{Feb}
(6) 
_{Mar}
(1) 
_{Apr}
(6) 
_{May}
(19) 
_{Jun}

_{Jul}

_{Aug}
(1) 
_{Sep}

_{Oct}

_{Nov}
(6) 
_{Dec}
(5) 
2007 
_{Jan}

_{Feb}
(5) 
_{Mar}
(1) 
_{Apr}
(1) 
_{May}

_{Jun}
(1) 
_{Jul}
(1) 
_{Aug}
(2) 
_{Sep}
(17) 
_{Oct}

_{Nov}
(5) 
_{Dec}
(32) 
2008 
_{Jan}

_{Feb}
(14) 
_{Mar}
(15) 
_{Apr}
(18) 
_{May}
(3) 
_{Jun}
(12) 
_{Jul}
(22) 
_{Aug}
(7) 
_{Sep}
(11) 
_{Oct}
(55) 
_{Nov}
(38) 
_{Dec}
(11) 
2009 
_{Jan}
(68) 
_{Feb}
(2) 
_{Mar}
(7) 
_{Apr}
(8) 
_{May}
(13) 
_{Jun}
(5) 
_{Jul}
(3) 
_{Aug}
(7) 
_{Sep}
(2) 
_{Oct}
(12) 
_{Nov}

_{Dec}
(6) 
2010 
_{Jan}
(5) 
_{Feb}
(2) 
_{Mar}
(50) 
_{Apr}
(5) 
_{May}
(9) 
_{Jun}
(5) 
_{Jul}
(4) 
_{Aug}
(3) 
_{Sep}

_{Oct}
(7) 
_{Nov}
(7) 
_{Dec}
(3) 
2011 
_{Jan}
(4) 
_{Feb}
(9) 
_{Mar}
(10) 
_{Apr}
(2) 
_{May}
(1) 
_{Jun}

_{Jul}

_{Aug}
(5) 
_{Sep}
(4) 
_{Oct}
(3) 
_{Nov}

_{Dec}

2012 
_{Jan}
(1) 
_{Feb}

_{Mar}

_{Apr}

_{May}
(20) 
_{Jun}
(3) 
_{Jul}
(2) 
_{Aug}
(4) 
_{Sep}

_{Oct}

_{Nov}

_{Dec}

2013 
_{Jan}

_{Feb}
(3) 
_{Mar}
(1) 
_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}
(1) 
_{Oct}

_{Nov}

_{Dec}

2014 
_{Jan}

_{Feb}

_{Mar}
(2) 
_{Apr}

_{May}

_{Jun}
(1) 
_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 






1

2

3

4
(1) 
5

6

7

8

9

10

11

12

13

14
(1) 
15
(1) 
16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

From: <yann.lepetitcorps@fr...>  20120615 00:33:28

> > > > Sorting neighboring pixel values is a particularly dumb method of > > > > doing a CWM filter (when all you want is the median), so fixing the > > > > dumb method of sorting is not really going to make the code good. > > > > The correct way to do CWM is roughly min(max(center,min(neighbors), > > > > max(neighbors)), at least for weight=4. (IIRC, this is from memory) > > > > If this is only for to find the median, this code seem to produce a good > > approximation of the true median for a 3x3 patch (in fact, this seem to > > return > > the true median value the majority of time) > > > > inline int median3(int a, int b, int c) > > { > > if ( a <= b ) > > { > > if ( b <= c ) > > return b; > > if ( c <= a ) > > return a; > > return c; > > } > > > > // a > b > > if ( a <= c ) > > return a; > > if ( b <= c ) > > return c; > > return b; > > } > > > > > > void fast_median3x3(int *d) > > { > > > > int m1, m2 ,m3, m4; > > > > m1 = median3(d[0], d[1], d[2]); > > m2 = median3(d[3], d[4], d[5]); > > m3 = median3(d[6], d[7], d[8]); > > > > return median3(m1,m2,m3); > > } > > > > Note that the median3() func is coded very ugly and can certainly to be > coded > > for to be very more speed > > (it only return the median from 3 values) > > > > On other side, I have found something that produce one approximation of > > the median for patchs biggers than 3x3, but the value returned can be very > > far > > from the true median value :( > > (n=9 for 3x3 patchs and n have always to be >= 3) > > > > > > int approx_median(int *d , int n) > > { > > > > int i, v, imin=255, imax=255, sum = 0; > > > > for (i= 0; i < n; i++ ) > > { > > v = d[i]; > > > > if (v < imin ) > > { > > imin = v; > > } > > else > > if ( v > imax ) > > { > > imax = v; > > } > > sum += v; > > } > > > > return (sum  imin  imax)/(n2); > > } > > > > In fact, this compute the mean but without the minimum and maximum extrems > > values > > (this can for example to be used for to filter pictures with a little > > impulsed > > white noise) > > Note too that with a very simple inversion of the j loop, we have already a > very > big reduction on the number of bubbles swaps (about 50%) > > int BubbleSort_ext(int *data, int n) > { > int i, j, tmp, nswaps = 0; > > for (i = 0 ; i < n ; i++) > { > /* for( j = i + 1 ; j < n ; j++) */ > for( j = n  1 ; j > i ; j) > { > if( data[i] > data[j] ) > { > nswaps++; > tmp = data[i]; > data[i] = data[j]; > data[j] = tmp; > } > } > } > > return nswaps; > } > > > Unsorted (16 values) : 206 188 63 212 135 171 238 21 224 153 234 208 16 67 84 > 109 > > > Original Bubble Sort : (70 swaps) > BubbleSorted v0 (16 values) : 16 21 63 67 84 109 135 153 171 188 206 208 212 > 224 > 234 238 > > > Modified Bubble Sort : (30 swaps) > BubbleSorted v1 (16 values) : 16 21 63 67 84 109 135 153 171 188 206 208 212 > 224 > 234 238 I have found something that at http://lodev.org/cgtutor/filtering.html that seem better :) int CombSort(int * data, int n) { int gap = n; bool swapped = false; int nswaps = 0; int i, j, tmp; while(gap > 1  swapped) { //shrink factor 1.3 gap = (gap * 10) / 13; if(gap == 9  gap == 10) gap = 11; if (gap < 1) gap = 1; swapped = false; for (i = 0; i < n  gap; i++) { j = i + gap; if (data[i] > data[j]) { tmp = data[i]; data[i] = data[j]; data[j] = tmp; swapped = true; nswaps++; } } } } Unsorted (16 values) : 131 246 150 152 240 228 18 234 57 93 68 216 62 75 78 238 Original Bubble Sort : (69 swaps) BubbleSorted v0 (16 values) : 18 57 62 68 75 78 93 131 150 152 216 228 234 238 240 246 Modified Bubble Sort : (39 swaps) BubbleSorted v1 (16 values) : 18 57 62 68 75 78 93 131 150 152 216 228 234 238 240 246 39 vs 69 swaps/assignments (43% reduction) Comb Sort : (15 swaps) Comb Sort (16 values) : 18 57 62 68 75 78 93 131 150 152 216 228 234 238 240 246 15 vs 69 swaps/assignments (78% reduction) => I begin to work about the "min(max(center,min(neighbors),max(neighbors))" way (I don't really understand what is exactely the method to use, but I think speedly understand this after some tests / researchs on the Net) @+ Yannoo 
From: <yann.lepetitcorps@fr...>  20120614 21:43:14

> > > Sorting neighboring pixel values is a particularly dumb method of > > > doing a CWM filter (when all you want is the median), so fixing the > > > dumb method of sorting is not really going to make the code good. > > > The correct way to do CWM is roughly min(max(center,min(neighbors), > > > max(neighbors)), at least for weight=4. (IIRC, this is from memory) > > If this is only for to find the median, this code seem to produce a good > approximation of the true median for a 3x3 patch (in fact, this seem to > return > the true median value the majority of time) > > inline int median3(int a, int b, int c) > { > if ( a <= b ) > { > if ( b <= c ) > return b; > if ( c <= a ) > return a; > return c; > } > > // a > b > if ( a <= c ) > return a; > if ( b <= c ) > return c; > return b; > } > > > void fast_median3x3(int *d) > { > > int m1, m2 ,m3, m4; > > m1 = median3(d[0], d[1], d[2]); > m2 = median3(d[3], d[4], d[5]); > m3 = median3(d[6], d[7], d[8]); > > return median3(m1,m2,m3); > } > > Note that the median3() func is coded very ugly and can certainly to be coded > for to be very more speed > (it only return the median from 3 values) > > On other side, I have found something that produce one approximation of > the median for patchs biggers than 3x3, but the value returned can be very > far > from the true median value :( > (n=9 for 3x3 patchs and n have always to be >= 3) > > > int approx_median(int *d , int n) > { > > int i, v, imin=255, imax=255, sum = 0; > > for (i= 0; i < n; i++ ) > { > v = d[i]; > > if (v < imin ) > { > imin = v; > } > else > if ( v > imax ) > { > imax = v; > } > sum += v; > } > > return (sum  imin  imax)/(n2); > } > > In fact, this compute the mean but without the minimum and maximum extrems > values > (this can for example to be used for to filter pictures with a little > impulsed > white noise) Note too that with a very simple inversion of the j loop, we have already a very big reduction on the number of bubbles swaps (about 50%) int BubbleSort_ext(int *data, int n) { int i, j, tmp, nswaps = 0; for (i = 0 ; i < n ; i++) { /* for( j = i + 1 ; j < n ; j++) */ for( j = n  1 ; j > i ; j) { if( data[i] > data[j] ) { nswaps++; tmp = data[i]; data[i] = data[j]; data[j] = tmp; } } } return nswaps; } Unsorted (16 values) : 206 188 63 212 135 171 238 21 224 153 234 208 16 67 84 109 Original Bubble Sort : (70 swaps) BubbleSorted v0 (16 values) : 16 21 63 67 84 109 135 153 171 188 206 208 212 224 234 238 Modified Bubble Sort : (30 swaps) BubbleSorted v1 (16 values) : 16 21 63 67 84 109 135 153 171 188 206 208 212 224 234 238 @+ Yannoo 
From: <yann.lepetitcorps@fr...>  20120604 19:47:55

Selon David Schleef <ds@...> : > > Sorting neighboring pixel values is a particularly dumb method of > > doing a CWM filter (when all you want is the median), so fixing the > > dumb method of sorting is not really going to make the code good. > > The correct way to do CWM is roughly min(max(center,min(neighbors), > > max(neighbors)), at least for weight=4. (IIRC, this is from memory) If this is only for to find the median, this code seem to produce a good approximation of the true median for a 3x3 patch (in fact, this seem to return the true median value the majority of time) inline int median3(int a, int b, int c) { if ( a <= b ) { if ( b <= c ) return b; if ( c <= a ) return a; return c; } // a > b if ( a <= c ) return a; if ( b <= c ) return c; return b; } void fast_median3x3(int *d) { int m1, m2 ,m3, m4; m1 = median3(d[0], d[1], d[2]); m2 = median3(d[3], d[4], d[5]); m3 = median3(d[6], d[7], d[8]); return median3(m1,m2,m3); } Note that the median3() func is coded very ugly and can certainly to be coded for to be very more speed (it only return the median from 3 values) On other side, I have found something that produce one approximation of the median for patchs biggers than 3x3, but the value returned can be very far from the true median value :( (n=9 for 3x3 patchs and n have always to be >= 3) int approx_median(int *d , int n) { int i, v, imin=255, imax=255, sum = 0; for (i= 0; i < n; i++ ) { v = d[i]; if (v < imin ) { imin = v; } else if ( v > imax ) { imax = v; } sum += v; } return (sum  imin  imax)/(n2); } In fact, this compute the mean but without the minimum and maximum extrems values (this can for example to be used for to filter pictures with a little impulsed white noise) PS : I always don't understand the signification of "min(max(center,min(neighbors),max(neighbors)), at least for weight=4" :( @+ Yannoo 