Image Processing - Convolution Filters with c++ and GDI+

• Download CImageProcessing.zip-56.3KB

Introduction

Image Convolution filters allows you to apply various effects on photos for certain features.

In essential a convolution filter it’s just a matrix. For every pixel of the image you take the sum of products. Each product is the color value of the current pixel or a neighbor of it, with the corresponding value of the filter matrix. The sum of the products is divided by a factor, and optionally is added an offset value.

Usually the factor is the sum of all values in the matrix filter, which ensures the end value will be in the range 0-255. 

There are numerous types of matrix filters: smoothing, Gaussian blur, edge detection, etc. The main issue in matrix convolution is that it requires a biggest number of computations. To avoid this issue you can reduce the size of the filter. Most of the time small filters 3x3 can do the job perfectly.

Using the source code

You can use the following class to apply 6 different convolution filters described hereinafter.

class CMatrixFilter { public: CMatrixFilter(long dwSize); ~CMatrixFilter(void); void ApplyRGB24Filter(BYTE * pBuff , int nWidth , int nHeight , UINT filter); void GrayscaleRGB(BYTE *picData , int nWidth , int nHeight , int nBitCount); void SubstractColor(BYTE *picSrc , int width , int height , int bpp); protected: void InitFilter(UINT selFilter); //matrix filters static int gaussMatrix[FILTER_DIMENSION][FILTER_DIMENSION]; static int sharpenMatrix[FILTER_DIMENSION][FILTER_DIMENSION]; static int mean_removalMatrix[FILTER_DIMENSION][FILTER_DIMENSION]; static int embossingMatrix[FILTER_DIMENSION][FILTER_DIMENSION]; static int edgeDetectionMatrix[FILTER_DIMENSION][FILTER_DIMENSION]; static int smothMatrix[FILTER_DIMENSION][FILTER_DIMENSION]; private: BYTE* temp; int matrixFilter[FILTER_DIMENSION][FILTER_DIMENSION]; int dwFilterSum; int dwFilterAdd; };

The following function applies a specified convolution filter to an image buffer bytes. The image should be in RGB24 pixel format.

BYTE * pBuff – image buffer
int nWidth – image width
int nHeight – image height
UINT filter – convolution filter identifier as follow:

• GAUSSIAN_BLUR
• SHARPEN
• MEAN_REMOVAL
• EMBOSSING
• EDGE_DETECTION
• SMOTH

void CMatrixFilter::ApplyRGB24Filter(BYTE * pBuff , int nWidth , int nHeight , UINT filter) { InitFilter(filter); memcpy(temp,pBuff,nWidth*nHeight*3); UINT x,y; int nPixel; int dwStride = (nWidth * (24 / 8) + 3) & ~3; //long dwOffset = dwStride - nWidth * 3; for( y = 0; y< nHeight-2;++y) { for( x = 0 ; x<nWidth-2; ++x) { long dep = (x*3) +(y*dwStride)/*+(y*dwOffset)*/; long depNextLine = dep + dwStride; long depNextNextLine = depNextLine + dwStride; nPixel = ((temp[2 + dep] * matrixFilter[0][0]) + (temp[5 + dep] * matrixFilter[0][1]) + (temp[8 + dep] * matrixFilter[0][2]) + (temp[2 + depNextLine] * matrixFilter[1][0])+ (temp[5 + depNextLine ] * matrixFilter[1][1]) + (temp[8 +depNextLine] * matrixFilter[1][2]) + (temp[2 + depNextNextLine]* matrixFilter[2][0]) + (temp[5 +depNextNextLine]* matrixFilter[2][1]) + (temp[8 + depNextNextLine]* matrixFilter[2][2])) ; pBuff[5 + depNextLine] = max(0,min(nPixel/dwFilterSum+dwFilterAdd, 255 )); nPixel = ((temp[1 + dep] * matrixFilter[0][0]) + (temp[4 + dep] * matrixFilter[0][1]) + (temp[7 + dep] * matrixFilter[0][2]) + (temp[1 + depNextLine] * matrixFilter[1][0])+ (temp[4 + depNextLine ] * matrixFilter[1][1]) + (temp[7 +depNextLine] * matrixFilter[1][2]) + (temp[1 + depNextNextLine]* matrixFilter[2][0]) + (temp[4 +depNextNextLine]* matrixFilter[2][1]) + (temp[7 + depNextNextLine]* matrixFilter[2][2])) ; pBuff[4+ depNextLine] = max(0,min(nPixel/dwFilterSum+dwFilterAdd, 255 )); nPixel = ((temp[0 + dep] * matrixFilter[0][0]) + (temp[3 + dep] * matrixFilter[0][1]) + (temp[6 + dep] * matrixFilter[0][2]) + (temp[0 + depNextLine] * matrixFilter[1][0])+ (temp[3 + depNextLine ] * matrixFilter[1][1]) + (temp[6 +depNextLine] * matrixFilter[1][2]) + (temp[0 + depNextNextLine]* matrixFilter[2][0]) + (temp[3 +depNextNextLine]* matrixFilter[2][1]) + (temp[6 + depNextNextLine]* matrixFilter[2][2])) ; pBuff[3+ depNextLine] = max(0,min(nPixel/dwFilterSum+dwFilterAdd, 255 )); } } }

The following method converts a RGB image to gray scale.

BYTE *picData – image buffer
int nWidth  – image width
int nHeight – image height
int nBitCount – number of bits per pixel

void CMatrixFilter::GrayscaleRGB(BYTE *picData , int nWidth , int nHeight , int nBitCount) { int BytesPerScanLine = (nWidth * (nBitCount / 8) + 3) & ~3; BYTE *r, *g, *b; int index = 0; for (int cy=0; cy<nHeight; cy++) { index = cy * BytesPerScanLine; for (int cx=0; cx < BytesPerScanLine; cx+=3) { b = &picData[index]; g = &picData[index + 1]; r = &picData[index + 2]; *r = (BYTE)((*r + *g + *b)/3); *g = *r; *b = *r; index += 3; } } }

The following function applies a color subtraction filter to a specified image.

BYTE *picSrc – image buffer
int width – image width
int height – image height
int bpp – bytes per pixel

void CMatrixFilter::SubstractColor(BYTE *picSrc , int width , int height , int bpp) { UINT i ; long size = width*height*bpp; for(i = 0; i< size; i++) picSrc[i] = 255 - picSrc[i]; }

Smoothing

This effect is applied in order to reduce noise and/or to prepare images for further processing such as segmentation. The output image is based on a local averaging of the input filter where all of the values within the filter support have the same weight.

Gaussian Blur

Gaussian blur, it is a widely used effect in graphics software, typically to reduce image noise and reduce detail. A Gaussian Blur is distinct from other blurs in that it has a well defined effect on different levels of detail within an image. As the level of detail becomes smaller the filter lets through less and less. With other types of blur (e.g. Mean Filter) the amount let through may vary considerably.

Sharpen

Sharpening filters are used to enhance the edges of objects and adjust the contrast and the shade characteristics. In combination with threshold they can be used as edge detectors. Sharpening or high-pass filters let high frequencies pass and reduce the lower frequencies and are extremely sensitive to shut noise.

Mean Removal

This filter sharpens the image by changing the colors of neighboring pixels with approximately the same color, so that small differences are evened out.

Embossing

The Emboss filter makes a selection appear raised or stamped by suppressing the color within the selection and tracing its edges with black.

Edge Detection

Edge detection is a terminology in image processing and computer vision, particularly in the areas of feature detection and feature extraction, to refer to algorithms which aim at identifying points in a digital image at which the image brightness changes sharply or more formally has discontinuities.

Update history

License

This article, along with any associated source code and files, is licensed under The Intelliproject Open License (IPOL)

About the author