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

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

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

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

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);