ConvolutionFilter  - AS3

Valor de transparência alfa da cor substituta. Os valores válidos são 0 a 1,0. O padrão é 0. Por exemplo, ,25 define um valor de transparência de 25%.

Quantidade de desvio a ser adicionado ao resultado da transformação de matriz. O desvio aumenta o valor de cor de cada canal para que as cores escuras pareçam mais brilhantes. O valor padrão é 0.

Indica se a imagem devem ser fixada. Para pixels fora da imagem de origem, um valor true indica que a imagem de entrada é estendida ao longo de cada uma de suas bordas, conforme necessário, duplicando os valores de cor em cada borda respectiva da imagem de entrada. Um valor de false indica que outra cor deve ser usada, conforme especificado nas propriedades color e alpha. O padrão é true.

 package {
    import flash.display.Sprite;
    import flash.display.BitmapData;
    import flash.filters.ConvolutionFilter;
    import flash.text.TextField;
    import flash.geom.Rectangle;
    import flash.geom.Point;

    public class ConvolutionClampExample extends Sprite {
        // Variables that affect clamping:
        var clamp:Boolean = false;
        var clampColor:Number = 0xFF0000;
        var clampAlpha:Number = 1;
        
        // For illustration, keep other ConvolutionFilter variables neutral:
        var bias:Number = 0;
        var preserveAlpha:Boolean = false;
        // Also, construct a neutral matrix
        var matrixCols:Number = 3;
        var matrixRows:Number = 3;
        var matrix:Array = [ 1,1,1,
                             1,1,1,
                             1,1,1 ];
        
        var filter:ConvolutionFilter = new ConvolutionFilter(matrixCols, matrixRows, matrix, matrix.length, bias, preserveAlpha, clamp, clampColor, clampAlpha);
        
        var largeBoxWidth:Number = 100;
        var largeBoxHeight:Number = 100;
        var largeBox:BitmapData = new BitmapData(largeBoxWidth, largeBoxWidth, true, 0xCC00FF00);
        var smallBoxWidth:Number = largeBoxWidth / 2;
        var smallBoxHeight:Number = largeBoxHeight / 2;
        var smallBox:BitmapData = new BitmapData(smallBoxWidth, smallBoxWidth, true, 0xCC0000FF);
            
        var mc:MovieClip = this.createEmptyMovieClip("mc", this.getNextHighestDepth());
        mc.attachBitmap(largeBox, this.getNextHighestDepth());
        
        mc.onPress = function() {
            largeBox.applyFilter(smallBox,
                                 new Rectangle(0,0, largeBoxWidth, largeBoxHeight),
                                 new Point(0,0),
                                 filter);
        }
    }
}

Cor hexadecimal para substituir pixels que estão fora da imagem de origem. É um valor RGB sem componente alfa. O padrão é 0.

Divisor usado durante a transformação de matriz. O valor padrão é 1. Um divisor que é a soma de todos os valores de matriz suaviza a intensidade geral de cores do resultado. Um valor 0 é ignorado e o padrão é usado em seu lugar.

Matriz de valores usados para transformação de matriz. O número de itens na matriz deve ser igual a matrixX * matrixY.

Uma convolução de matriz é baseada em uma matriz n x m, que descreve como um determinado valor de pixel na imagem de entrada é combinado com seus valores de pixel próximos para produzir um valor de pixel resultante. Cada pixel resultante é determinado pela aplicação da matriz ao pixel de origem correspondente e a seus pixels próximos.

Para uma convolução de matriz 3 x 3, a fórmula a seguir é usada para cada canal de cor independente:

	dst (x, y) = ((src (x-1, y-1) * a0 + src(x, y-1) * a1....
	                  src(x, y+1) * a7 + src (x+1,y+1) * a8) / divisor) + bias
	

Determinadas especificações de filtro são realizadas mais rapidamente quando executadas por um processador que oferece SSE (Streaming SIMD Extensions). Veja em seguida os critérios para operações de convolução mais rápidas:

• O filtro deve ser um filtro 3x3.
• Todos os termos do filtro devem ser inteiros entre -127 e +127.
• A soma de todos os termos do filtro não deve ter um valor absoluto maior do que 127.
• Se algum termo do filtro for negativo, o divisor deve estar entre 2,00001 e 256.
• Se todos os termos do filtro forem positivos, o divisor deve estar entre 1,1 e 256.
• O desvio deve ser um inteiro.

Observação: Se você criar uma ocorrência ConvolutionFilter usando o construtor sem parâmetros, a ordem atribuída aos valores para as propriedades da matriz afetará o comportamento do filtro. No caso a seguir, a matriz é atribuída enquanto as propriedades matrixX e matrixY ainda são definidas como 0 (valor padrão):

    public var myfilter:ConvolutionFilter = new ConvolutionFilter();
    myfilter.matrix = [0, 0, 0, 0, 1, 0, 0, 0, 0];
    myfilter.matrixX = 3;
    myfilter.matrixY = 3;
    

No caso a seguir, a matriz é atribuída enquanto as propriedades matrixX e matrixY são definidas como 3:

    public var myfilter:ConvolutionFilter = new ConvolutionFilter();
    myfilter.matrixX = 3;
    myfilter.matrixY = 3;
    myfilter.matrix = [0, 0, 0, 0, 1, 0, 0, 0, 0];
    

Dimensão x da matriz (número de colunas na matriz). O valor padrão é 0.

Dimensão y da matriz (número de linhas na matriz). O valor padrão é 0.

Indica se o canal alfa é preservado sem o efeito de filtro ou se o filtro de convolução é aplicado ao canal alfa e aos canais de cor. Um valor false indica que a convolução se aplica a todos os canais, incluindo o canal alfa. Um valor de true indica que a convolução se aplica somente aos canais de cor. O valor padrão é true.

Inicializa uma ocorrência ConvolutionFilter com os parâmetros especificados.

Retorna uma cópia deste objeto de filtro.

A função buildChild() cria um novo objeto Loader chamado loader. Para cada chamada para buildChild(), anexe um tratamento de eventos ao objeto Loader para tratar dos eventos complete, que são manipulados pela função passada para buildChild().

As funções applyBrightness(), applySharpness() e applyOutline() usam diferentes valores para a matriz matrix para obter diferentes efeitos do ConvolutionFilter.

Nota: para obter melhores resultados, use uma imagem de aproximadamente 80 pixels de largura. O nome e o local do arquivo de imagem deve corresponder ao valor passado para a propriedade url. Por exemplo, o valor passado para url no exemplo aponta para um arquivo de imagem chamado "Image.jpg" que está no mesmo diretório que seu arquivo SWF.

package {
    import flash.display.DisplayObject;
    import flash.display.Loader;
    import flash.display.Sprite;
    import flash.events.*;
    import flash.filters.BitmapFilter;
    import flash.filters.ConvolutionFilter;
    import flash.net.URLRequest;
    import flash.text.TextField;
    import flash.text.TextFieldAutoSize;

    public class ConvolutionFilterExample extends Sprite {
        private var size:uint = 140;
        private var url:String = "Image.jpg";

        public function ConvolutionFilterExample() {
            buildChild(applyNothing);
            buildChild(applyBrightness);
            buildChild(applySharpness);
            buildChild(applyOutline);
        }

        private function buildChild(loadHandler:Function):void {
            var loader:Loader = new Loader();
            loader.x = numChildren * size;
            loader.y = size;
            loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
            if(loadHandler != null) {
                loader.contentLoaderInfo.addEventListener(Event.COMPLETE, loadHandler);
            }

            var request:URLRequest = new URLRequest(url);
            loader.load(request);
            addChild(loader);
        }

        private function applyNothing(event:Event):void {
            var child:DisplayObject = DisplayObject(event.target.loader);
            applyLabel(child, "no filter");
        }

        private function applyBrightness(event:Event):void {
            var child:DisplayObject = DisplayObject(event.target.loader);
            var matrix:Array = [5, 5, 5,
                                5, 0, 5,
                                5, 5, 5];
            applyFilter(child, matrix);
            applyLabel(child, "brightness");
        }

        private function applySharpness(event:Event):void {
            var child:DisplayObject = DisplayObject(event.target.loader);
            var matrix:Array = [0, -1, 0,
                               -1, 20, -1,
                                0, -1, 0];
            applyFilter(child, matrix);
            applyLabel(child, "sharpness");
        }

        private function applyOutline(event:Event):void {
            var child:DisplayObject = DisplayObject(event.target.loader);
            var matrix:Array = [-30, 30, 0,
                                -30, 30, 0,
                                -30, 30, 0];
            applyFilter(child, matrix);
            applyLabel(child, "outline");
        }

        private function applyFilter(child:DisplayObject, matrix:Array):void {
            var matrixX:Number = 3;
            var matrixY:Number = 3;
            var divisor:Number = 9;
            var filter:BitmapFilter = new ConvolutionFilter(matrixX, matrixY, matrix, divisor);
            var filters:Array = new Array();
            filters.push(filter);
            child.filters = filters;
        }

        private function applyLabel(child:DisplayObject, label:String):void {
            var tf:TextField = new TextField();
            tf.x = child.x;
            tf.y = child.height;
            tf.autoSize = TextFieldAutoSize.LEFT;
            tf.text = label;
            addChild(tf);
        }

        private function ioErrorHandler(event:IOErrorEvent):void {
            trace("Unable to load image: " + url);
        }
    }
}