任意方向へのブラー

エフェクト処理の中に任意方向へのブラーを追加
こんな感じ
ソースは右クリックで見れます。

前回のやつを任意の方向効果をかけられるようにした感じです。

追加した部分のソース

//任意方向へのブラー
private function effect_blur_arb(ef:int, ang:int):void{
    if(target_bmpData == null) return;
    bmpData2 = new BitmapData(target_bmpData.width, target_bmpData.height);
    
    var nn:int;
    var px:Array = [], py:Array = [], pat:Array = [];
    var mx:int;
    var pat_sum:int;
    var oo:int = 0;
    var mask_ary:Array;
    
    //フィルタの大きさ
    mx = 2*ef+1;
    
    //マスクパターンが入った配列の取得
    mask_ary = makeBlurPat(mx, ang, px, py, pat, pat_sum);
    var count:int = mx*mx;
    for(var i:int = 0; i < count; i++){
        oo += mask_ary[i];
    }
    var filter:ConvolutionFilter = new ConvolutionFilter(mx, mx, mask_ary, oo);
    
    bmpData2 = target_bmpData.clone();
    bmpData2.applyFilter(bmpData2, bmpData2.rect, new Point, filter);
    
    view.bitmapData = target_bmpData = bmpData2;
    myImage.width = view.width = myImage.width;
    myImage.height = view.height = myImage.height;
}

private function linarPol(c1:int, c2:int, c3:int, c4:int, xr:Number, yr:Number):int{
    var d:Number, e:Number, f:Number;
    var res:int;
    
    d = Number(c1)*(1.0-xr)+Number(c3)*xr;
    e = Number(c2)*(1.0-xr)+Number(c4)*xr;
    f = d*(1.0-yr)+e*yr;
    res = (f + 0.5);
    if(res > 255) res = 255;
    else if(res < 0) res = 0;
    return res;
}

private function getPatVal(mat:Array, n:int, x:int, y:int):int{
    if(x < 0 || y < 0 || x >= n || y >= n) return 0;
    
    return mat[x+y*n];
}

private function linearInterpolate(mat:Array, n:int, x1:Number, y1:Number):int{
    var mx:int, my:int, dep:int;
    var px:int, py:int;
    var nx:int, ny:int;
    var xrate:Number, yrate:Number;
    var col1:int, col2:int, col3:int, col4:int, col_n:int;
    
    nx = int(x1);
    ny = int(y1);
    px = int(x1);
    py = int(y1);
    xrate = x1 - Number(px);
    yrate = y1 - Number(py);
    col1 = getPatVal(mat, n, px, py);
    col2 = getPatVal(mat, n, px, py+1);
    col3 = getPatVal(mat, n, px+1, py);
    col4 = getPatVal(mat, n, px+1, py+1);
    return linarPol(col1, col2, col3, col4, xrate, yrate);
}

private function makeBlurPat(n:int, ang:int, x:Array, y:Array, val:Array, sum:int):Array{
    var tmpv:Array=[];
    var mat:Array=[];
    var msum:int, tsum:int;
    var i:int;
    var vv:int;
    var hf:int;
    var rad:Number;
    var fx:Number, fy:Number, tx:Number, ty:Number;
    var sinT:Number, cosT:Number;
    var mask_ary:Array = [];
    
    hf = n / 2;
    
    //配列の初期化
    for(var yy:int = 0; yy < n; yy++){
        for(var xx:int = 0; xx < n; xx++){
            mat[xx+yy*n] = 0;
        }
    }
    
    msum = 0;
    
    for(xx = 0; xx < n; xx++){
        vv = 1;
        mat[xx+hf*n] = vv;
        msum += vv;
    }
    
    mat[hf+hf*n] = 3;
    rad = Number(ang)*Math.PI/180.0;
    sinT = Math.sin(rad);
    cosT = Math.cos(rad);
    
    i = 0;
    tsum = 0;
    for(yy = 0; yy < n; yy++){
        for(xx = 0; xx < n; xx++){
            tx = Number(xx-hf);
            ty = Number(yy-hf);
            fx = cosT*tx+sinT*ty + Number(hf);
            fy = -sinT*tx+cosT*ty + Number(hf);
            vv = linearInterpolate(mat, n, fx, fy);
            mask_ary[i] = vv;
            tsum += vv;
            i++;
        }
    }
    
    val = tmpv;
    sum = tsum;
    return mask_ary;
}