Простые растровые операции

Все существующие графические объекты можно разделить на два типа: векторные и растровые.

Векторные объекты обычно описываются координатами и математическими формулами.

Самые распространенные программы для работы с объектами этого типа - Corel Draw и Adobe Illustrator.

Основные преимущества векторной графики:

• изменение масштаба без потери качества;
• зависимость размера файла от количества объектов, а не от размера холста.

Основной недостаток - чем больше объектов, тем больше требуется вычислительной мощности компьютера для работы с ними.

Растровые файлы представляют собой массив точек, для каждой из которых задается значение цвета.

Самые распространенные программы для работы с растровой графикой - Adobe Photoshop, Corel PhotoPaint и GIMP.

Основное преимущество использования растровой графики - любой объект можно перевести в растровый формат.

Основные недостатки:

• размер файла зависит от размера холста;
• большой объем оперативной памяти и вычислительной мощности, необходимый для обработки растровых файлов;
• увеличение рисунка всегда сопровождается потерей качества.

Рассмотрим изнутри работу некоторых функций и фильтров графических редакторов растровой графики.

Первое, что нам нужно - это разместить файлы в памяти компьютера для того, чтобы вывести их на экран и редактировать. Работать мы будем с файлом формата BMP (Windows Bitmap), который имеет 24 бита на цвет.

Файл состоит из четырех разделов: заголовок файла, заголовок растра, палитра цветов (в данном примере палитры не будет) и растровые данные.

Нужные нам данные сохраним в структурах:

LPBITMAPINFO pPicInfo; 	//заголовок растра
BYTE *pPicture;		     //растровые данные (картинка)

Загрузка файла:

BOOL PicLoad(CString sFileName)	//передается имя рисунка
{
	BITMAPFILEHEADER FileHead; 	  //заголовок файла
	CFile oFile;
	if(!oFile.Open(sFileName, CFile::modeRead))
		return(FALSE);
	oFile.Read(&FileHead, sizeof(BITMAPFILEHEADER));
	if(FileHead.bfType!=0x4D42) 	  //проверка: является ли файл рисунком в BMP формате
	{
		oFile.Close();
		return(FALSE);
	}
	oFile.Seek(sizeof(BITMAPFILEHEADER), CFile::begin);
	if((pPicInfo=(LPBITMAPINFO)new BYTE[FileHead.bfOffBits-sizeof(BITMAPFILEHEADER)])==NULL)
	{
		oFile.Close();
		return(FALSE);
	}
	oFile.Read(pPicInfo, FileHead.bfOffBits-sizeof(BITMAPFILEHEADER)); 	//считывание заголовка растра в только что выделенную память
	if(pPicInfo->bmiHeader.biCompression!=0) 	//поскольку программа учебная, мы работаем только с несжатыми файлами
	{
		oFile.Close();
		return(FALSE);
	}
	oFile.Seek(FileHead.bfOffBits, CFile::begin);
	iBytePerLine=((GetPicWidth()*pPicInfo->bmiHeader.biBitCount+31)>>5)<<2; 	//вычисляется количество байт на 1 линию
	if(pPicInfo->bmiHeader.biSizeImage==0) 	//если в файле не задан размер, корректируем это упущение
		pPicInfo->bmiHeader.biSizeImage=iBytePerLine*GetPicHeight();
	pPicture=new BYTE[pPicInfo->bmiHeader.biSizeImage]; 	//выделяем память под сами растровые данные
	if(pPicture==NULL)
	{
		oFile.Close();
		return(FALSE);
	}
	oFile.Read(pPicture, pPicInfo->bmiHeader.biSizeImage); 	//загружаем картинку в память
	oFile.Close();
	return(TRUE);
}

В памяти картинка расположена точка за точкой, начиная с верхнего левого угла вправо, далее вторая строка, третья, ..., до правого нижнего угла. Каждая точка представлена тремя байтами, каждый байт - это интенсивность цвета от 0 до 255. Первый байт - это B (Blue-синий), G (Green-зеленый) и R (Red-красный). В формате BMP каждая стока должна быть описана целым числом двойных слов, это должно быть учтено, информация в этих байтах может быть любой, поскольку она нигде не используются.

Вывод изображения на экран

Забегая вперед, уточним, что для работы некоторых фильтров необходимо две области памяти, одна с оригиналом рисунка, другая - буфер для результата применения фильтра. Принимая этот факт к рассмотрению, нужно организовать два буфера для изображения и указатель на память, в которой находиться текущая картинка. Таким образом, у нас уже организовалась возможность отмены действия, и если результат применения фильтра нам не нравится, мы просто присваиваем указателю на текущую картинку значение области памяти с исходным изображением. Отменить таким образом можно только одно действие, повторная отмена действия опять поменяет местами результат и источник. Для реализации множественной отмены нужно создать несколько буферов, используя массивы (в том числе динамические).

Для вывода используем стандартную функцию StretchDIBits

//режим вывода изображения
int iOldStretchMode=SetStretchBltMode(hdc, COLORONCOLOR);
//вывод изображения в контекст устройства hdc с сохранением пропорций
StretchDIBits(hdc, 0, 0, GetPicWidth(), GetPicHeight(), 0, 0, GetPicWidth(), GetPicHeight(), pPicture, pPicInfo, DIB_RGB_COLORS, SRCCOPY);

Точечные преобразования

Рассмотрим графические фильтры. Их можно разделить на две категории:

точечные - новое значение элемента рассчитывается на основании его старого значения;

пространственные - при расчете учитывается старое значение пиксела, а также значения близлежащих пикселов.

Более подробное рассмотрение начнем с точечных фильтров, как с наиболее простых.

Расчет "Гистограммы яркости"

Гистограмма - это график частоты появления точек различных степеней яркости. Гистограмма предназначена для определения распределения яркости в изображении и более равномерного распределения.

По оси Х расположена интенсивность яркости от 0 (светлые тона) до 255 (темные тона), по оси Y частота появления. Для изображения в градациях черного необходимо посчитать частоту появления точек всех яркостей и вывести на экран эти значения (в процентах).

Для цветного изображения каждый цвет имеет разный весовой коэффициент и рассчитывается по формуле

Расчет гистограммы

//pHistogram[iX] - массив, в котором хранятся значения яркостей
//Перед расчетом нужно его обнулить, потому что точек с каким-то значением яркости может и не быть
for(int iX=0; iX<256; iX++)	pHistogram[iX]=0;
//перебирая все точки рисунка подряд, рассчитываем значение яркости, которое имеет текущая точка,
//это значение есть № ячейки массива, значение которой мы увеличиваем на единицу
BYTE *pCurrPixel=NULL;	//указатель на текущий пиксель
for(int iY=0; iYMoveTo(x, y);
	y=oFrameRect.bottom-(int)(ky*pHistogram[i]+0.5);
	if(yLineTo(x, y);	//длина линии соответствует частоте появления текущей (i) яркости
}

Корректировка диапазона яркости

После того, как мы видим гистограмму фотографии, мы можем подкорректировать диапазон яркости картинки. Для примера посмотрим на фотографию пловца.

От теории к практике.

Вызываем диалоговое окно, в котором пользователь корректирует диапазон и нажимает ОК. В результате у нас есть два значения

int iOffset_b;	//смещение в светлых тонах
int iOffset_t;	//смещение в темных тонах

int iOffset_256=256-iOffset_t;	//т.к. в диалоге мы получаем значение - на сколько сместить от 255

//все что за диапазоном доводим до максимума. Для светлых тонов - максимально светлый - 0,
//для темных максимально темный - 255
for(int ix=0; ix=iOffset_256; ix--)
	RGBTransformTable[0][ix]=RGBTransformTable[1][ix]=RGBTransformTable[2][ix]=255;

BYTE RGBTransformTable[color][index] - это таблица преобразования цветов, которая, представлена двухмерным массивом.

Color - определяет цвет, для которого мы хотим получить новое значение. У нас цветов три - RGB и, соответственно, размерность равна трем.

Index - это индекс в массиве, который определяет ячейку, в которой храниться новое значение яркости.

Т.е. допустим, мы хотим применить некоторое изменение яркости по значениям, которые записаны в таблице преобразования. Берем точку с координатами (0, 0) и смотрим, какую она имеет яркость, например, R=36, G=89, B=231. Новые значения яркости берем из таблицы преобразования:

В красный цвет записываем значение из ячейки RGBTransformTable[0][36],

зеленый - RGBTransformTable[1][89],

синий - RGBTransformTable[2][231].

Дальше изменяем остальные точки. В этой части кода нам понадобиться функция, которая, получая координаты точки, будет возвращать его адрес. Это функция

BYTE *GetPixel(LONG x, LONG y)
{
	return(pPicture+(iBytePerLine*y+x*pPicInfo->bmiHeader.biBitCount/8));
}

Теперь перебираем последовательно все точки и изменяем значение яркости pSourcePic - указатель на картинку источник (фотография, к которой мы применяем фильтр), pDestPic - буфер, в который мы помещаем результат.

BYTE *pDestPixel=NULL, *pSourPixel=NULL;
for(int  y=0; yGetPicHeight(); y++)
	for(int x=0; xGetPicWidth(); x++)
	{
		pDestPixel=pDestPic->GetPixel(x, y);
		pSourPixel=pSourcePic->GetPixel(x, y);
		*pDestPixel=RGBTransformTable[0][*pSourPixel];
		*(pDestPixel+1)=RGBTransformTable[0][*(pSourPixel+1)];
		*(pDestPixel+2)=RGBTransformTable[0][*(pSourPixel+2)];
	}

Думаю, что с назначением массива RGBTransformTable[][] все понятно. Осталось только его заполнить, т.к. теорию мы уже рассмотрели, код заполнения не должен вызвать трудности.

//равномерно растягиваем диапазон яркости от iOffset_b до iOffset_256
double fStep=256.0/((double)(256-(iOffset_b+iOffset_t)));
double fCol=0.0;
for(int ix=iOffset_b; ix<iOffset_256; ix++)
{
	RGBTransformTable[0][ix]=RGBTransformTable[1][ix]=RGBTransformTable[2][ix]=(int)(fCol+0.5);
	fCol+=fStep;
}

Как уже говорилось выше, после применения фильтров результат, находящийся в буфере, необходимо вывести на экран. Теперь адрес pSourcePic указывает не на картинку, а на буфер, в который мы будем помещать результат следующих трансформаций, а pDestPic - указывает на картинку-оригинал (Undo - меняет эти значения местами).

Фильтр "Инверсия цветов"

Это самый простой фильтр, как в понимании, так и в реализации. Он изменяет цвета на противоположные, если точка была белой - меняем на черную.

Фильтр "Инверсия цветов" реализуется также посредством таблицы преобразования, только заполняется эта таблица другим методом.

for(int ix=0; ix<256; ix++)
{
	RGBTransformTable[0][ix]=255-ix;
	RGBTransformTable[1][ix]=255-ix;
	RGBTransformTable[2][ix]=255-ix;
}

Смена цвета каждой точки ничем не отличается от рассмотренного в "Корректировке диапазона яркости".

Фильтр изменения "Яркости/Контраста"

Изменение яркости заключается в увеличении или уменьшении интенсивности всех пикселей на заданное значение (одинаковое для всех каналов).

Значения, на которые нам нужно изменить яркость и контрастность, мы получаем из диалогового окна

for(ix=0; ix<256; ix++)
{
	ibx=ix+iBrigh;	//увеличение на iBrigh единиц, может быть как положительным, так и отрицательным
	if(ibx > 255)
	{
		RGBTransformTable[0][ix]=255;
		RGBTransformTable[1][ix]=255;
		RGBTransformTable[2][ix]=255;
	}
	else 
		if(ibx < 0)
		{
			RGBTransformTable[0][ix]=0;
			RGBTransformTable[1][ix]=0;
			RGBTransformTable[2][ix]=0;
		}
		else
		{
			RGBTransformTable[0][ix]=ibx;
			RGBTransformTable[1][ix]=ibx;
			RGBTransformTable[2][ix]=ibx;
		}
}

С контрастом дело обстоит немного сложнее. Заполнение таблицы преобразования будем делать, исходя из "серой середины"

#define MEDIUM_CONTRAST 159

Значение 159 больше среднего арифметического (127). Это значение ближе к понятию "серый цвет", чем RGB(127, 127, 127) - темно-серый и RGB(200, 200, 200) - светло-серый. Со значением RGB(159, 159, 159) достигается более реалистичный эффект.

Чтобы откорректировать контраст, сначала сместим яркость на нужную величину, а затем либо "сжатие", любо "растяжение" диапазона яркости. При "сжатии" диапазона яркости значения будут изменяться не равномерно, а пропорционально их удаленности от "серой середины". "Растяжение" сделано аналогично за исключением того, что смещение по шкале яркости сверху и снизу одинаково.

#define MEDIUM_CONTRAST 159
int ix=0, iIndexT=0, iIndexB=0, iColorOffset=0, ibx, iLimitB, iLimitT;
double fCol=0.0, fStep;
if(iContrast<0)	// iContrast - значение, на которое корректируем контраст
{
	for(ibx=0; ibx<3; ibx++)	//последовательно перебираем все каналы
		for(ix=0; ix<256; ix++)
			if(RGBTransformTable[ibx][ix] MEDIUM_CONTRAST)
					RGBTransformTable[ibx][ix]=MEDIUM_CONTRAST;
				else
					RGBTransformTable[ibx][ix]-=iColorOffset;
			}else
			{
				iColorOffset=(RGBTransformTable[ibx][ix]-MEDIUM_CONTRAST)*iContrast/128;
				if((RGBTransformTable[ibx][ix]+iColorOffset) < MEDIUM_CONTRAST)
					RGBTransformTable[ibx][ix]=MEDIUM_CONTRAST;
				else
					RGBTransformTable[ibx][ix]+=iColorOffset;
			}
}else
	if(iContrast>0)
	{
		iLimitB=iContrast*MEDIUM_CONTRAST/128;
		for(ibx=0; ibx<3; ibx++)
			for(iIndexB=0; iIndexB<256; iIndexB++)
			{
				if(RGBTransformTable[ibx][iIndexB] 255)
					RGBTransformTable[ibx][iIndexT]=255;
				else break;
			}
		fStep=256.0/((double)(256-iLimitB+iLimitB));
		for(ibx=0; ibx<3; ibx++)
		{
			fCol=0.0;
			for(ix=iIndexB; ix=iLimitB || RGBTransformTable[ibx][ix]<256-iLimitT)
				{
					fCol=(double)((int)((double)(RGBTransformTable[ibx][ix]-iLimitB)*fStep+0.5));
					RGBTransformTable[ibx][ix]=((fCol>255.0)?(255):(int)fCol);
				}
			}
		}
	}

После заполнения таблицы RGBTransformTable[][]изменяем значения всех точек, как было рассмотрено выше.

Фильтр "Рельеф"

Этот фильтр имеет несколько реализаций, в данной статье мы рассмотрим точечную реализацию. Результат работы фильтра можно сравнить с рисунком на "незастывшем" бетоне. Достигается такой эффект вычитанием яркости точки из яркости точки той же позиции, но смещенной на несколько пикселов в сторону и вверх (смещать можно и других направлениях). Полученная разница смещается в область серых тонов.

#define EMBOSS_X 3		//задаем смещение по оси Х
#define EMBOSS_Y -3	//задаем смещение по оси Y
BYTE *pDestPix=NULL, *pSourPix1=NULL, *pSourPix2=NULL, iBr1, iBr2, iBrResult;
//(x, y) - координаты точки, для которой делаем преобразование, последовательно перебираем все точки фотографии
pDestPix=pDestPic->GetPixel(x, y);	//адрес точки в буфере (куда поместить результат)
pSourPix1=pSourPic->GetPixel(x, y); //адрес точки источника (первая точка)
pSourPix2=pSourPic->GetPixel(x+EMBOSS_X, y+EMBOSS_Y);	//адрес точки (источника), смещенной на несколько пикселей (вторая точка)
iBr1=(BYTE)(0.11*(*pSourPix1)+0.59*(*(pSourPix1+1))+0.3*(*(pSourPix1+2)));	//рассчитываем яркость для 1-ой точки
iBr2=(BYTE)(0.11*(*pSourPix2)+0.59*(*(pSourPix2+1))+0.3*(*(pSourPix2+2)));	//яркость 2-ой точки
iBrResult=(iBr1-iBr2+255)/2;		//рассчитываем яркость и смещаем ее в область серых тонов
*pDestPix=iBrResult;		       //запись результата во все три канала
*(pDestPix+1)=iBrResult;
*(pDestPix+2)=iBrResult;

Пространственные (матричные) преобразования

Последующие фильтры будут пространственными (матричными). Пространственные преобразования заключаются в нахождении свертки значений пикселов. Свертка вычисляется как сумма пиксельных значений, попавших в зону преобразования, помноженных на весовые коэффициенты. Для расчетов используется матрица:

размер матрицы - задает область пикселов, которые будут учитываться при преобразовании;

элементы матрицы - весовые коэффициенты;

все значения элементов матрицы - тип преобразования.

Фильтр "Размытие"

Расчет нового элемента можно осуществлять с использованием следующего псевдокода:

int iMatrixX=5;				          //размерность 5х5
int iMatrixY=5;
const int iBlurMatrix[25]=				//Матрица для размытия:
{	1, 1, 1, 1, 1,
	1, 1, 1, 1, 1,
	1, 1, 1, 1, 1,
	1, 1, 1, 1, 1,
	1, 1, 1, 1, 1
};
const int *pMatrix=iBlurMatrix;	//указатель на матрицу

//на рассчитываемую точку указывают координаты (x, y)
//pDestPixel - адрес указывает на точку в буфере, по которому мы записываем результат
BYTE *pSourPixel=NULL;		//указатель на пиксель
int iNewPixel=0;				  //новое значение пикселя
int iSymmaCoef=0;			  //подсчет суммы коэффициентов
for(int iY=-iMatrixY/2; iY<iMatrixY; iY++)
	for(int iX=-iMatrixX/2; iX<iMatrixX; iX++)
	{
		pSourPixel=GetPixel(x+iX, y+iY);		//получаем адрес точки с учетом смещения
		iNewPixel = iNewPixel + (*pSourPixel)*pMatrix[iY][iX];
		iSymmaCoef= iSymmaCoef + pMatrix[iY][iX];
	}
*pDestPixel=iNewPixel/iSymmaCoef;		//записываем новое значение элемента

Этот же расчет проводим для остальных каналов, далее переходим к следующей точке.

Если для предыдущих операций можно было результат помещать в ту же область памяти, что и оригинал, то для матричных фильтров необходимы две области памяти.

Фильтр "Контур"

Работа этого фильтра происходит аналогично размытию, все, что нужно - это изменить значения матрицы и ее разрядность.

#define CONTUR 3		//коэффициент четкости, можно задать в диалоговом окне
const int iConturMatrix[9]=
{ -1*CONTUR, -1*CONTUR, -1*CONTUR,
  -1*CONTUR,  8*CONTUR, -1*CONTUR,
  -1*CONTUR, -1*CONTUR, -1*CONTUR
};
pMatrix=iConturMatrix;
iMatrixX=3;		//размерность матрицы 3х3
iMatrixY=3;

Сумма элементов матрицы равна нулю. Если яркость пикселов, попавших в зону действия матрицы примерно одинакова, - результат будет близкий к нулю. А если преобразуемый пиксель имеет яркость, отличную от окружающих, - результат будет больше нуля. Результат работы всего фильтра - черное изображение с белым контуром.

Фильтр "Четкость"

Поскольку фильтр матричный, ему нужна матрица:

pMatrix=iBlurMatrix;
iMatrixX=5;
iMatrixY=5;

В данном случае ничего не перепутано, для работы фильтра действительно нужна такая же матрица, как и при размытии. Фильтр "Четкость" иллюстрирует собой борьбу противоположностей. Для повышения четкости картинки нужно сначала размыть изображение, а потом вычислить разность между размытым изображением и оригиналом, на величину этой разности изменяется разность оригинала. В результате однородные участки изменятся незначительно, а высокочастотные участки изображения станут более контрастными.

#define SHARP 3		//коэффициент усиления
//
//размываем точку фильтром "Размытие", код приведен выше
//
//pSourPix - адрес точки (картинка оригинал)
//pDestPix - адрес точки (картинка после применения преобразований, буфер)
int iResult=((*pSourPix)-(*pDestPix))*SHARP;		//получаем новое значение яркости
*pDestPix= (*pDestPix) + iResult;		            //записываем новое значение

Заключение

Соберем все выше сказанное в один блок:

class CPicture			//класс по работе с изображением
{
private:
	BYTE *pPicture;
	LPBITMAPINFO pPicInfo;
public:
	LONG iBytePerLine;
public:
	BOOL PicLoad(CString sFileName);		//загрузка изображения с файла
	BOOL PicSave(CString sFileName);		//запись в файл
	void PicDelete();			            //удаление картинки из памяти
	void PicDraw(CDC *pDC);			       //вывод на экран
	RGBQUAD *GetColorTable(void)		     //возвращает указатель на таблицу цветов
		{	return((LPRGBQUAD)(((BYTE*)(pPicInfo))+sizeof(BITMAPINFOHEADER))); };
	BYTE *GetPixel(LONG x, LONG y);		//адрес пикселя (x, y)
	BOOL GetHistogram(DWORD *pHistogram);		//расчет гистограммы
	LONG GetPicWidth(void)		//ширина картинки
		{	return((pPicInfo==NULL)?(0):pPicInfo->bmiHeader.biWidth);	};
	LONG GetPicHeight(void)		//высота картинки
		{	return((pPicInfo==NULL)?(0):pPicInfo->bmiHeader.biHeight);	};
	LPBITMAPINFO GetPicInfo(void)	//возвращает указатель заголовка растра
	{	return(pPicInfo);	};
	BYTE *GetPicture(void)		//возвращает указатель на растровые данные
	{	return(pPicture);	};
};

Работа фильтров во многом схожа, поэтому их вполне логично объединить

class CFilter		//базовый класс
{
protected:
	CPicture *pSourPic;		//указатель на "оригинал" изображения
	CPicture *pDestPic;		//указатель на буфер, куда будет помещено изображение после преобразования
public:
	virtual BOOL TransformPix(LONG x, LONG y)		//виртуальный метод, реализация будет переопределяться
			{	return(FALSE);	};
};

Дальше фильтры делятся на два направления: точечные и матричные

class CDotFilter : public CFilter			   //базовый класс точечных фильтров
{
protected:
	BYTE RGBTransformTable[3][256];	     //таблица преобразования
public:
	BOOL TransformPix(LONG x, LONG y);		//трансформация пикселя
};
BOOL CDotFilter::TransformPix(LONG x, LONG y)
{
	BYTE *pDestPixel=NULL, *pSourPixel=NULL;
	if(pSourPic==NULL)		//источник необходим
		return(FALSE);
	if(pDestPic==NULL)		//буфер не обязателен
		pDestPic=pSourPic;
	if((pDestPixel=pDestPic->GetPixel(x, y))==NULL || (pSourPixel=pSourPic->GetPixel(x, y))==NULL)
		return(FALSE);
//изменяем изображение, используя таблицу преобразования
	*pDestPixel=RGBTransformTable[0][*pSourPixel];	*(pDestPixel+1)=RGBTransformTable[0][*(pSourPixel+1)];
	*(pDestPixel+2)=RGBTransformTable[0][*(pSourPixel+2)];
	return(TRUE);
}
//------------------------------------------------
class CMatrixFilter : public CFilter		//базовый класс для матричных фильтров
{
protected:
	int iMatrixX;		       //размерность матрицы
	int iMatrixY;
	const int *pMatrix;		//указатель на матрицу
public:
	BOOL TransformPix(LONG x, LONG y);		//трансформация пикселя
};
BOOL CMatrixFilter::TransformPix(LONG x, LONG y)
{
	BYTE *pDestPixel=NULL, *pSourPixel=NULL;
	int iXStart=0, iYStart=0, iXFinish=iMatrixX, iYFinish=iMatrixY;
	if(pSourPic==NULL || pDestPic==NULL)	//источник и буфер необходимы
		return(FALSE);
    if(x-iMatrixX/2<0)
		iXStart=iMatrixX/2-x;
	if(y-iMatrixY/2<0)
		iYStart=iMatrixY/2-y;
	if(x+iMatrixX/2>pSourPic->GetPicWidth())
		iXFinish-=(x+iMatrixX/2-pSourPic->GetPicWidth());
	if(y+iMatrixY/2>pSourPic->GetPicHeight())
		iYFinish-=(y+iMatrixY/2-pSourPic->GetPicHeight());
	int iNewRGB[3], iCount, c, iX, iY;
	for(c=0; c<3; c++)			//расчет для всех каналов цвета
	{
		iNewRGB[c]=0;
		iCount=0;
		for(iY=iYStart; iYGetPixel(x+(iX-iMatrixX/2), y+(iY-iMatrixY/2)))!=NULL)
				{		//свертывает яркость точки
					iNewRGB[c]+=(pMatrix[iY*iMatrixX+iX]*(*(pSourPixel+c)));
					iCount+=pMatrix[iY*iMatrixX+iX];
				}
			}
	}
    pDestPixel=pDestPic->GetPixel(x,y);
	for(c=0; c<3; c++)
	{
		if(iCount!=0)
			iNewRGB[c]=iNewRGB[c]/iCount;
		if(iNewRGB[c]<0)
			iNewRGB[c]=0;
		else
			if(iNewRGB[c]>255)
				iNewRGB[c]=255;
		*(pDestPixel+c)=iNewRGB[c];		//записываем новое значение яркости
	}
	return(TRUE);
}

Точечные фильтры

class CHistogram : public CDotFilter		//гистограмма
{
public:
	BOOL Init(int iOffset_b, int iOffset_t);
};//------------------------------------------------
class CBrightContrast : public CDotFilter		//яркость/контраст
{
public:
	BOOL Init(int iBrigh, int iContrast);
};//------------------------------------------------
class CInvertColor : public CDotFilter		//инверсия
{
public:
	CInvertColor();		//инициализация таблицы преобразования
};//------------------------------------------------
class CEmboss : public CDotFilter			//рельеф
{
public:
	BOOL TransformPix(LONG x, LONG y);
};
class CToGrayscale : public CDotFilter		//перевод в градации серого
{
public:
	BOOL TransformPix(LONG x, LONG y);
};

Матричные фильтры

class CBlur : public CMatrixFilter		//размытие
{
public:
	CBlur();
};//------------------------------------------------
class CContur : public CMatrixFilter		//контур
{
public:
	CContur();
};//------------------------------------------------
class CSharp : public CMatrixFilter		//четкость
{
public:
	CSharp();
	BOOL TransformPix(LONG x, LONG y);
};

Вызов фильтров

Заведем переменную CFilter *pCurrentFilter, которая будет указывать на активный фильтр. Когда пользователь выбирает нужный ему фильтр из меню, программа помещает адрес этого фильтра в переменную pCurrentFilter и вызывает функцию:

void CPainterDoc::Transform(void)
{
	//CPicture *pSourcePic; - адрес оригинала картинки
	//CPicture *pDistancePic; - адрес буфера
	LONG x, y;
	for(y=0; yGetPicHeight(); y++)		//перебираем последовательно все точки
		for(x=0; xGetPicWidth(); x++)
			pCurrentFilter->TransformPix(x, y);				//вызов функции преобразования для текущего фильтра
	SetModifiedFlag();		//после преобразования устанавливаем флаг, картинка изменена
}