[djyamato]

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

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

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м скрине это хорошо видно), подскажите, где я мог ошибиться ?