stack(s)

// Super Fast Blur v1.1
// by Mario Klingemann <http://incubator.quasimondo.com>
// converted to C++ by Mehmet Akten, <http://www.memo.tv>
//
// Tip: Multiple invovations of this filter with a small
// radius will approximate a gaussian blur quite well.
//

#include “ImageFilters.h”

void superFastBlur(unsigned char *pix, int w, int h, int radius) {

if (radius<1) return;
int wm=w-1;
int hm=h-1;
int wh=w*h;
int div=radius+radius+1;
unsigned char *r=new unsigned char[wh];
unsigned char *g=new unsigned char[wh];
unsigned char *b=new unsigned char[wh];
int rsum,gsum,bsum,x,y,i,p,p1,p2,yp,yi,yw;
int *vMIN = new int[MAX(w,h)];
int *vMAX = new int[MAX(w,h)];

unsigned char *dv=new unsigned char[256*div];
for (i=0;i<256*div;i++) dv[i]=(i/div);

yw=yi=0;

for (y=0;y<h;y++){
rsum=gsum=bsum=0;
for(i=-radius;i<=radius;i++){
p = (yi + MIN(wm, MAX(i,0))) * 3;
rsum += pix[p];
gsum += pix[p+1];
bsum += pix[p+2];
}
for (x=0;x<w;x++){

r[yi]=dv[rsum];
g[yi]=dv[gsum];
b[yi]=dv[bsum];

if(y==0){
vMIN[x]=MIN(x+radius+1,wm);
vMAX[x]=MAX(x-radius,0);
}
p1 = (yw+vMIN[x])*3;
p2 = (yw+vMAX[x])*3;

rsum += pix[p1] - pix[p2];
gsum += pix[p1+1] - pix[p2+1];
bsum += pix[p1+2] - pix[p2+2];

yi++;
}
yw+=w;
}

for (x=0;x<w;x++){
rsum=gsum=bsum=0;
yp=-radius*w;
for(i=-radius;i<=radius;i++){
yi=MAX(0,yp)+x;
rsum+=r[yi];
gsum+=g[yi];
bsum+=b[yi];
yp+=w;
}
yi=x;
for (y=0;y<h;y++){
pix[yi*3] = dv[rsum];
pix[yi*3 + 1] = dv[gsum];
pix[yi*3 + 2] = dv[bsum];
if(x==0){
vMIN[y]=MIN(y+radius+1,hm)*w;
vMAX[y]=MAX(y-radius,0)*w;
}
p1=x+vMIN[y];
p2=x+vMAX[y];

rsum+=r[p1]-r[p2];
gsum+=g[p1]-g[p2];
bsum+=b[p1]-b[p2];

yi+=w;
}
}

delete r;
delete g;
delete b;

delete vMIN;
delete vMAX;
delete dv;
}