ConvolutionFilter  - AS3

Valor de transparencia alfa del color opcional. Los valores válidos van de 0 a 1,0. El valor por defecto es 0. Por ejemplo, 0,25 establece un valor de transparencia del 25%.

Cantidad de sesgo que debe añadirse al resultado de la transformación de matriz. El sesgo aumenta el valor de color de cada canal para que los colores oscuros parezcan más claros. El valor predeterminado es 0.

Indica si la imagen debe fijarse. Para los píxeles que quedan fuera de la imagen de origen, un valor true indica que la imagen de entrada se amplía a lo largo de cada uno de sus bordes cuanto sea necesario duplicando los valores de color en cada borde de la imagen de entrada. false indica que se utilizará otro color, según se haya especificado en las propiedades color y alpha. El valor predeterminado es 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);
        }
    }
}

Color hexadecimal para reemplazar los píxeles que quedan fuera de la imagen de origen. Es un valor RGB sin componente alfa. El valor por defecto es 0.

Divisor que se utiliza durante la transformación de matriz. El valor predeterminado es 1. Un divisor que es la suma de todos los valores de matriz suaviza la intensidad de color general del resultado. Se ignora un valor de 0 y en su lugar se utiliza el valor predeterminado.

Conjunto de valores que se utiliza para la transformación del conjunto. El número de elementos de la matriz debe ser igual a matrixX * matrixY.

Una convolución de matriz se basa en una matriz n x m, que describe cómo el valor de un píxel determinado en la imagen de entrada se combina con los valores de los píxeles colindantes para producir un valor de píxel resultante. Cada píxel resultante se determina aplicando la matriz al píxel de origen correspondiente y a los píxeles colindantes.

Para una convolución de matriz 3 x 3 se emplea la fórmula siguiente para cada canal de color independiente:

	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
	

Algunas especificaciones de filtro se ejecutan más rápidamente cuando se utiliza un procesador con SSE (Streaming SIMD Extensions). A continuación, se indican criterios para conseguir operaciones de convolución más rápidas:

• El filtro debe ser de 3x3.
• Todos los términos del filtro deben ser enteros entre -127 y +127.
• El valor absoluto de la suma de todos los términos del filtro no debe ser mayor de 127.
• Si alguno de los términos del filtro es negativo, el divisor debe estar entre 2,00001 y 256.
• Si todos los términos del filtro son positivos, el divisor debe estar entre 1,1 y 256.
• El sesgo debe ser un entero.

Nota: si se crea una instancia de ConvolutionFilter utilizando el constructor sin parámetros, el orden en que se asignan los valores a las propiedades de la matriz afecta al comportamiento del filtro. En el siguiente caso, el conjunto se asigna mientras que las propiedades matrixX y matrixY siguen definidas en 0 (valor predeterminado):

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

En el siguiente caso, el conjunto se asigna mientras que las propiedades matrixX y matrixY están definidas en 3:

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

La dimensión x de la matriz (el número de columnas de la matriz). El valor predeterminado es 0.

La dimensión y de la matriz (el número de filas de la matriz). El valor predeterminado es 0.

Indica si el canal alfa se conserva sin el efecto de filtro o si se aplica el filtro de convolución al canal alfa, así como a los canales de color. Un valor false indica que la convolución se aplica a todos los canales, incluido el canal alfa. true indica que la convolución sólo se aplica a los canales de color. El valor predeterminado es true.

Inicializa una instancia ConvolutionFilter con los parámetros especificados.

Devuelve una copia de este objeto de filtro.

La función buildChild() crea un nuevo objeto Loader denominado loader. Para cada llamada a buildChild(), se asocia un detector de eventos al objeto Loader para detectar eventos complete que se controlan con la función transferida a buildChild().

Las funciones applyBrightness(), applySharpness() y applyOutline() utilizan distintos valores para el conjunto matrix para conseguir distintos efectos de ConvolutionFilter.

Nota: para obtener los mejores resultados, utilice una imagen de aproximadamente 80 píxeles de anchura. El nombre y la ubicación del archivo de imagen deben coincidir con el valor transferido a la propiedad url. Por ejemplo, el valor transferido a url en el ejemplo señala a un archivo de imagen llamado "Image.jpg" que se encuentra en el mismo directorio que el archivo 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);
        }
    }
}