Having trouble with Box Blur Edges - c

Question

I am a newbie hobbyist trying to program a box blur and I am having trouble with respect to edges. I am hoping that someone can spot the error.
The edges are black and I am assuming that it's because the borders are not being reflected properly. I am sure this has been discussed with a fix size kernel however I am using a variable sized kernel.
I am using the code found on another post --
Optimized float Blur variations
However I just do not understand the reflected borders portion.
I do not really care if optimized or not nor do I care about other kernel shapes, box shape will be just fine.
The code is
{// code from https://stackoverflow.com/questions/7860575/optimized-float-blur-variations
//--------------------------------------
int image_width ;
int image_height ;
int scale = 0;
int weight = (radius * 2) + 1;
int kernel_X = 0;
int kernel_Y = 0;
//--------------------------------------
float sum = 0.0;
int kernel_width = radius;//set both to the same to make the kernel square
int kernel_height = radius;//set both to the same to make the kernel square
// HORIZONTAL
for(iy = 0; iy < image_height ;iy++)
{
sum = 0.0;
// Process entire window for first pixel (including wrap-around edge)
for (kernel_X = 0; kernel_X <= kernel_width; kernel_X++)
{
if (kernel_X >= 0 && kernel_X < image_width)
//sum += src[iy * image_width ];
sum += src[iy * image_width + kernel_X];
}
//>-------------- border code does not reflect edges HELP!!
// Wrap watch for left side of image & resulting black bar
for (kernel_X = (image_width - kernel_width); kernel_X < image_width; kernel_X++)
{
// if (kernel_X >= 0 && kernel_X < image_width)// HORIZONTAL width = horizontal = X
// sum += src[iy * kernel_width + image_width ];//<-------------------enter tester formula here
// sum += src[iy + ix * image_width + kernel_X];//<-------------------FAIL
// sum += src[iy * kernel_width + image_width ];//<-------------------streaky
}
// Store first window
tmp[iy * image_width] = (sum / weight );
for(ix = 1; ix < image_width; ix++)
{
// Subtract pixel leaving window
if (ix - kernel_width - 1 >= 0)
sum -= src[iy * image_width + ix - kernel_width - 1];
// Add pixel entering window
if (ix + kernel_width < image_width)
sum += src[iy * image_width + ix + kernel_width];
else
sum += src[iy * image_width + ix + kernel_width - image_width];
tmp[iy * image_width + ix] = (sum / weight);//just for testing
}
}
// VERTICAL
for(ix = 0; ix < image_width; ix++)
{
sum = 0.0;
// Process entire window for first pixel
for (kernel_Y = 0; kernel_Y <= kernel_height; kernel_Y++)
{
if (kernel_Y >= 0 && kernel_Y < image_height)
sum += tmp[kernel_Y * image_width + ix];
}
//>-------------- border code does not reflect edges HELP!!
// Wrap watch for top side of image & resulting black bar
for (kernel_Y = image_height-kernel_height; kernel_Y < kernel_height; kernel_Y++)
{
//if (kernel_Y >= 0 && kernel_Y < image_height)
// sum += tmp[(iy + kernel_height - image_height) * image_width + ix];
}
for(iy=1;iy< image_height ;iy++)
{
// Subtract pixel leaving window
if (iy-kernel_height-1 >= 0)
sum -= tmp[(iy - kernel_height-1) * image_width + ix];
// Add pixel entering window
if (iy + kernel_height < image_height)
sum += tmp[(iy + kernel_height) * image_width + ix];
else
sum += tmp[(iy + kernel_height - image_height) * image_width + ix];
dst[ (scale * image_width * image_height) + (iy * image_width + ix) ] = (sum / weight);
}
}
}
I appreciate any help on this.
Thanks
John
edit here are some links of image examples of the edges.
image with proper box blur
http://img687.imageshack.us/img687/931/standardboxblur.jpg
Image with improper edges using the above code (notice dark bar on Top and Left edges, bottom and right are not quite right either)
http://img202.imageshack.us/img202/5137/boxblurbadedges.jpg

Answer 1

It might be easiest if you put your sampling into a separate routine which, given an x and y coordinate, returns the pixel value. You can then do some checks and clamp the x and y values to be between 0 and width and 0 and height, respectively. Then you can safely pass in negative values or values greater than width or height. It also allows you to more easily try other schemes like reflection, clamping to a color, extrapolation, etc. Simply swap out the sampling function that clamps with one that does some other behavior.