Алгоритм фильтра повышения резкости, где у меня неправильно ?

djyamato · 20.11.2010, 20:24

Здравствуйте, нашел алгоритм для повышения резкости тут (Создание графических фильтров для обработки изображений)

написал такой вот код

Код AS3:

import flash.display.BitmapData;
import flash.display.Bitmap;
import flash.geom.Matrix;
 
var ThisSWF=this;
 
var sampleBD:BitmapData=new BitmapData(sample.width,sample.height,true,0xFFFFFF);
sampleBD.draw(sample); // картинка на стэйдже (у меня это мувиклин с именем 'sample')
 
var tmpBitmap:Bitmap;
 
tmpBitmap=new Bitmap(sampleBD);
tmpBitmap.x=sample.x+sample.width+30;
tmpBitmap.y=sample.y;
ThisSWF.addChild(tmpBitmap);
 
var res:BitmapData=new BitmapData(sample.width,sample.height,true,0xFFFFFF);
 
var Pixel:uint;
var LU:uint;
var U:uint;
var RU:uint;
var R:uint;
var RD:uint;
var D:uint;
var LD:uint;
var L:uint;
 
 
// colors
var r:uint;
var g:uint;
var b:uint;
 
 
var X:int;
var Y:int;
 
var sharpArray=new Array(-.1,-.1,-.1,-.1,1.8,-.1,-.1,-.1,-.1);
var smoothArray=new Array(.05,.05,.05,.05,.6,.05,.05,.05,.05);
var delit=1;
 
SHARPEN.addEventListener("mouseUp",sharpenHandler);
 
function sharpenHandler(event:Event):void{
	if(tmpBitmap!=null){
		if(ThisSWF.contains(tmpBitmap)){
			ThisSWF.removeChild(tmpBitmap);
			sampleBD=tmpBitmap.bitmapData.clone();
		}
	}
	res=new BitmapData(sample.width,sample.height,false,0xFF0000);
	setFilter(sharpArray);
	tmpBitmap=new Bitmap(res);
	tmpBitmap.x=sample.x+sample.width+30;
	tmpBitmap.y=sample.y;
	ThisSWF.addChild(tmpBitmap);
}
 
function setFilter(arr):void{
	for (Y=1; Y<sampleBD.height-1; Y+=1) {
		for (X=1; X<sampleBD.width-1; X+=1) {
			var redSumm:uint=0;
			var greenSumm:uint=0;
			var blueSumm:uint=0;
 
			Pixel=sampleBD.getPixel(X,Y); // прочли пиксель
 
			var PixelR:uint=getRed(Pixel);
			var PixelG:uint=getGreen(Pixel);
			var PixelB:uint=getBlue(Pixel);
			PixelR=PixelR*arr[4];
			PixelG=PixelG*arr[4];
			PixelB=PixelB*arr[4];
 
			redSumm+=PixelR;
			greenSumm+=PixelG;
			blueSumm+=PixelB;
 
 
			LU=sampleBD.getPixel(X-1,Y-1);
			var LU_R:uint=getRed(LU);
			var LU_G:uint=getGreen(LU);
			var LU_B:uint=getBlue(LU);
			LU_R=LU_R*arr[0];
			LU_G=LU_G*arr[0];
			LU_B=LU_B*arr[0];
 
 
 
			redSumm+=LU_R;
			greenSumm+=LU_G;
			blueSumm+=LU_B;
 
 
			U=sampleBD.getPixel(X,Y-1);
			var U_R:uint=getRed(U);
			var U_G:uint=getGreen(U);
			var U_B:uint=getBlue(U);
			U_R=U_R*arr[1];
			U_G=U_G*arr[1];
			U_B=U_B*arr[1];
 
			redSumm+=U_R;
			greenSumm+=U_G;
			blueSumm+=U_B;
 
 
			RU=sampleBD.getPixel(X+1,Y-1);
			var RU_R:uint=getRed(RU);
			var RU_G:uint=getGreen(RU);
			var RU_B:uint=getBlue(RU);
			RU_R=RU_R*arr[2];
			RU_G=RU_G*arr[2];
			RU_B=RU_B*arr[2];
 
			redSumm+=RU_R;
			greenSumm+=RU_G;
			blueSumm+=RU_B;
 
 
			R=sampleBD.getPixel(X+1,Y);
			var R_R:uint=getRed(R);
			var R_G:uint=getGreen(R);
			var R_B:uint=getBlue(R);
			R_R=R_R*arr[5];
			R_G=R_G*arr[5];
			R_B=R_B*arr[5];
 
			redSumm+=R_R;
			greenSumm+=R_G;
			blueSumm+=R_B;
 
 
			RD=sampleBD.getPixel(X+1,Y+1);
			var RD_R:uint=getRed(RD);
			var RD_G:uint=getGreen(RD);
			var RD_B:uint=getBlue(RD);
			RD_R=RD_R*arr[8];
			RD_G=RD_G*arr[8];
			RD_B=RD_B*arr[8];
 
			redSumm+=RD_R;
			greenSumm+=RD_G;
			blueSumm+=RD_B;
 
 
			D=sampleBD.getPixel(X,Y+1);
			var D_R:uint=getRed(D);
			var D_G:uint=getGreen(D);
			var D_B:uint=getBlue(D);
			D_R=D_R*arr[7];
			D_G=D_G*arr[7];
			D_B=D_B*arr[7];
 
			redSumm+=D_R;
			greenSumm+=D_G;
			blueSumm+=D_B;
 
 
			LD=sampleBD.getPixel(X-1,Y+1);
			var LD_R:uint=getRed(LD);
			var LD_G:uint=getGreen(LD);
			var LD_B:uint=getBlue(LD);
			LD_R=LD_R*arr[6];
			LD_G=LD_G*arr[6];
			LD_B=LD_B*arr[6];
 
			redSumm+=LD_R;
			greenSumm+=LD_G;
			blueSumm+=LD_B;
 
 
			L=sampleBD.getPixel(X-1,Y);
			var L_R:uint=getRed(L);
			var L_G:uint=getGreen(L);
			var L_B:uint=getBlue(L);
			L_R=L_R*arr[3];
			L_G=L_G*arr[3];
			L_B=L_B*arr[3];
 
			redSumm+=L_R;
			greenSumm+=L_G;
			blueSumm+=L_B;
 
			redSumm=redSumm*delit;
			greenSumm=greenSumm*delit;
			blueSumm=blueSumm*delit;
 
			if(redSumm>255){
				redSumm=255;
			}
			if(greenSumm>255){
				greenSumm=255;
			}
			if(blueSumm>255){
				blueSumm=255;
			}
			if(redSumm<0){
				redSumm=0;
			}
			if(greenSumm<0){
				greenSumm=0;
			}
			if(blueSumm<0){
				blueSumm=0;
			}
			res.setPixel(X,Y,(redSumm*256*256+greenSumm*256+blueSumm));
		}
	}
}
 
function getRed(num:uint):uint{
	return (num >> 16);
}
 
function getGreen(num:uint):uint{
	return ((num >> 8) & 0xFF);
}
 
function getBlue(num:uint):uint{
	return (num & 0xFF);
}

Если подставлять smoothArray, то картинка смягчается правильно (по крайней мере, визуально похоже на размытие), на первом скрине это видно, а если подставить sharpArray, возникают ошибки (на 2м скрине это хорошо видно), подскажите, где я мог ошибиться ?

TERRORist · 20.11.2010, 21:30

имхо 3х3 матрицы мало для фильтра резкости, 5х5 было б интереснее (как в фотошопе)
коэффициенты должны быть явно пониже, а так оч даже похоже на обычную резкость.
Можно было б замутить что нить позаковыристей. например, вводить матрицу руками в 25 полей ввода. Наглядней было б.

Вобще для таких штук PixelBender создан. покомпактнее, работать будет во много раз быстрее

djyamato · 20.11.2010, 21:36

Спасибо за ответ, ну а почему пиксели-то лезут не те ?
про ПикселБендер уже давно думаю, но в начале хочу теорию этого всего понять

и еще, 5x5 марица, а коэффициенты для нее отправные какие взять ?

TERRORist · 20.11.2010, 22:45

Подход неправильный - у тебя пиксели перекрашиваются слева направо сверху вниз на одной картинке.
Надо брать пиксель из старой картинки и копировать с изменением в новую.

djyamato · 20.11.2010, 23:30

а как они должны перекрашиваться ? справа-налево снизу-вверх ?

TERRORist · 21.11.2010, 00:00

Цитата:

Сообщение от TERRORist

Надо брать пиксель из старой картинки и копировать с изменением в новую.

(новая - и будет результатом обработки)

djyamato · 21.11.2010, 00:43

переделал чтобы читалось попиксельно из одной BitmapData (sampleBD) и записывалось в другую (res)

Код AS3:

sampleBD=new BitmapData(sample.width,sample.height,false,0xFFFFFF);
sampleBD.draw(sample);
res=new BitmapData(sample.width,sample.height,false,0xFFFFFF);
tmpBitmap=new Bitmap(res);
setFilter(sharpArray);
 
tmpBitmap.x=sample.x+sample.width+30;
tmpBitmap.y=sample.y;
ThisSWF.addChild(tmpBitmap);

тут фильтрация пикселей

Код AS3:

function setFilter(){
 
   for (X=sampleBD.width; X>-1; X--) {
      for (Y=sampleBD.height; Y>-1; Y--) {
          Pixel=sampleBD.getPixel(X,Y); // прочли пиксель
 
          // нахождение точек и расчеты
          res.setPixel(X,Y,(redSumm*256*256+greenSumm*256+blueSumm));
      }
   }
}

все равно эти несколько пикселей "неправильного" цвета

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

TERRORist · 21.11.2010, 01:18

Тогда не знаю.. может там отрицательное значение цвета получилось? глюки только там где черные участки рядом с светлыми

djyamato · 21.11.2010, 01:20

Спасибо Вам, буду экспериментировать

iNils · 21.11.2010, 01:22

Можно использовать pixel binder. В сети есть готовые фильтры, например такой http://www.rphelan.com/2008/10/17/sh...bender-filter/