Kernel (image processing)

In image processing, a kernel, convolution matrix, or mask is a small matrix. It is used for blurring, sharpening, embossing, edge detection, and more. This is accomplished by doing a convolution between a kernel and an image.
Details.
The general expression of a convolution is
formula_1
where formula_2 is the filtered image, formula_3 is the original image, formula_4 is the filter kernel. Every element of the filter kernel is considered by formula_5 and formula_6.
Depending on the element values, a kernel can cause a wide range of effects.
The above are just a few examples of effects achievable by convolving kernels and images.
Origin.
The origin is the position of the kernel which is above (conceptually) the current output pixel. This could be outside of the actual kernel, though usually it corresponds to one of the kernel elements. For a symmetric kernel, the origin is usually the center element.
Convolution.
Convolution is the process of adding each element of the image to its local neighbors, weighted by the kernel. This is related to a form of mathematical convolution. The matrix operation being performed—convolution—is not traditional matrix multiplication, despite being similarly denoted by *.
For example, if we have two three-by-three matrices, the first a kernel, and the second an image piece, convolution is the process of flipping both the rows and columns of the kernel and multiplying locally similar entries and summing. The element at coordinates [2, 2] (that is, the central element) of the resulting image would be a weighted combination of all the entries of the image matrix, with weights given by the kernel:
formula_7
The other entries would be similarly weighted, where we position the center of the kernel on each of the boundary points of the image, and compute a weighted sum.
The values of a given pixel in the output image are calculated by multiplying each kernel value by the corresponding input image pixel values. This can be described algorithmically with the following pseudo-code:
 for each "image row" in "input image":
 for each "pixel" in "image row":
 set "accumulator" to zero
 for each "kernel row" in "kernel":
 for each "element" in "kernel row":
 if "element position" corresponding* to "pixel position" then
 multiply "element value" corresponding* to "pixel value"
 add "result" to "accumulator"
 endif
 set "output image pixel" to "accumulator"
If the kernel is symmetric then place the center (origin) of the kernel on the current pixel. The kernel will overlap the neighboring pixels around the origin. Each kernel element should be multiplied with the pixel value it overlaps with and all of the obtained values should be summed. This resultant sum will be the new value for the current pixel currently overlapped with the center of the kernel.
If the kernel is not symmetric, it has to be flipped both around its horizontal and vertical axis before calculating the convolution as above.
The general form for matrix convolution is
formula_8
Edge Handling.
Kernel convolution usually requires values from pixels outside of the image boundaries. There are a variety of methods for handling image edges.
Normalization.
Normalization is defined as the division of each element in the kernel by the sum of all kernel elements, so that the sum of the elements of a normalized kernel is unity. This will ensure the average pixel in the modified image is as bright as the average pixel in the original image.
Concrete implementation.
Here a concrete convolution implementation done with the GLSL shading language :
// author : csblo
// Work made just by consulting :
// https://en.wikipedia.org/wiki/Kernel_(image_processing)
// Define kernels
// Find coordinate of matrix element from index
vec2 kpos(int index)
 return vec2[9] (
 vec2(-1, -1), vec2(0, -1), vec2(1, -1),
 vec2(-1, 0), vec2(0, 0), vec2(1, 0), 
 vec2(-1, 1), vec2(0, 1), vec2(1, 1)
 )[index] / iResolution.xy;
// Extract region of dimension 3x3 from sampler centered in uv
// sampler : texture sampler
// uv : current coordinates on sampler
// return : an array of mat3, each index corresponding with a color channel
mat3[3] region3x3(sampler2D sampler, vec2 uv)
 // Create each pixels for region
 vec4[9] region;
 for (int i = 0; i < 9; i++)
 region[i] = texture(sampler, uv + kpos(i));
 // Create 3x3 region with 3 color channels (red, green, blue)
 mat3[3] mRegion;
 for (int i = 0; i < 3; i++)
 mRegion[i] = mat3(
 region[0][i], region[1][i], region[2][i],
 region[3][i], region[4][i], region[5][i],
 region[6][i], region[7][i], region[8][i]
 
 return mRegion;
// Convolve a texture with kernel
// kernel : kernel used for convolution
// sampler : texture sampler
// uv : current coordinates on sampler
vec3 convolution(mat3 kernel, sampler2D sampler, vec2 uv)
 vec3 fragment;
 // Extract a 3x3 region centered in uv
 mat3[3] region = region3x3(sampler, uv);
 // for each color channel of region
 for (int i = 0; i < 3; i++)
 // get region channel
 mat3 rc = region[i];
 // component wise multiplication of kernel by region channel
 mat3 c = matrixCompMult(kernel, rc);
 // add each component of matrix
 float r = c[0][0] + c[1][0] + c[2][0]
 + c[0][1] + c[1][1] + c[2][1]
 + c[0][2] + c[1][2] + c[2][2];
 // for fragment at channel i, set result
 fragment[i] = r;
 
 return fragment; 
void mainImage( out vec4 fragColor, in vec2 fragCoord )
 // Normalized pixel coordinates (from 0 to 1)
 vec2 uv = fragCoord/iResolution.xy;
 // Convolve kernel with texture
 vec3 col = convolution(emboss, iChannel0, uv);
 // Output to screen
 fragColor = vec4(col, 1.0);