ConvolutionFilter  - AS3

Il valore di trasparenza alfa del colore di sostituzione. I valori validi sono compresi tra 0 e 1.0. Il valore predefinito è 0. Ad esempio, 0.25 imposta un valore di trasparenza del 25%.

La variazione da aggiungere al risultato della trasformazione di matrice. La variazione aumenta il valore del colore di ogni canale, rendendo più vividi i colori scuri. Il valore predefinito è 0.

Indica se l'immagine deve essere fissata. Per i pixel esterni all'immagine di origine, il valore true indica che l'immagine di input viene estesa lungo ciascuno dei suoi bordi per quanto necessario duplicando i valori di colore ai rispettivi bordi dell'immagine di input. Un valore false indica che deve essere utilizzato un altro colore, come specificato nelle proprietà color e alpha. Il valore predefinito è 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);
        }
    }
}

Il colore esadecimale da sostituire ai pixel esterni all'immagine di origine. Si tratta di un valore RGB privo di componente alfa. Il valore predefinito è 0.

Il divisore utilizzato durante la trasformazione di matrice. Il valore predefinito è 1. Un divisore corrispondente alla somma di tutti i valori della matrice uniforma l'intensità di colore complessiva del risultato. Un valore pari a 0 viene ignorato e viene sostituito con il valore predefinito.

Un array di valori utilizzato per la trasformazione di matrice. Il numero di elementi nell'array deve equivalere a matrixX * matrixY.

La convoluzione matrice si basa su una matrice n per m, che descrive il modo in cui un determinato valore di pixel nell'immagine di input viene combinato con i valori di pixel adiacenti per generare un valore di pixel risultante. Ogni pixel risultante viene determinato dall'applicazione della matrice al pixel di origine corrispondente e ai pixel a esso adiacenti.

Per una convoluzione matrice 3 x 3 viene utilizzata la formula seguente per ogni singolo canale di colore:

	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
	

Quando vengono eseguite da un processore con SSE (Streaming SIMD Extensions), alcune specifiche di filtro agiscono più velocemente. Di seguito sono indicati i criteri per accelerare le operazioni di convoluzione:

• Il filtro deve essere di tipo 3x3.
• Tutti i termini del filtro devono essere numeri interi compresi tra -127 e +127.
• La somma di tutti i termini del filtro non deve avere un valore assoluto maggiore di 127.
• Se qualche termine è negativo, il divisore deve essere compreso tra 2,00001 e 256.
• Se tutti i termini sono positivi, il divisore deve essere compreso tra 1,1 e 256.
• La variazione (o bias) deve essere un numero intero.

Nota: se create un'istanza ConvolutionFilter mediante una funzione di costruzione senza parametri, l'ordine in cui assegnate i valori alle proprietà matrix influisce sul comportamento del filtro. Nell'esempio seguente, l'array matrix è assegnato mentre le proprietà matrixX e matrixY sono impostate su 0 (valore predefinito):

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

Nell'esempio seguente, l'array matrix è assegnato mentre le proprietà matrixX e matrixY sono impostate su 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 dimensione x della matrice (il numero di colonne della matrice). Il valore predefinito è 0.

La dimensione y della matrice (il numero di righe della matrice). Il valore predefinito è 0.

Indica se il canale alfa viene conservato senza l'effetto filtro o se il filtro di convoluzione viene applicato sia al canale alfa, sia ai canali di colore. Il valore false indica che la convoluzione viene applicata a tutti i canali, compreso il canale alfa. Il valore true indica che la convoluzione si applica solo ai canali di colore. Il valore predefinito è true.

Inizializza un'istanza ConvolutionFilter con i parametri specificati.

Restituisce una copia di questo oggetto filtro.

La funzione buildChild() crea un nuovo oggetto Loader denominato loader. Per ogni chiamata a buildChild(), associate un listener di eventi all'oggetto Loader per l'intercettazione degli eventi complete, che vengono gestiti dalla funzione passata a buildChild().

Le funzioni applyBrightness(), applySharpness() e applyOutline() utilizzano valori diversi per l'array matrix per ottenere effetti diversi dall'applicazione del filtro ConvolutionFilter.

Nota: per ottenere risultati ottimali, utilizzate un'immagine di circa 80 pixel di larghezza. Il nome e la posizione del file di immagine dovranno corrispondere al valore passato alla proprietà url. Ad esempio, il valore passato a url nell'esempio fa riferimento a un file di immagine denominato "Image.jpg" presente nella stessa directory del file 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);
        }
    }
}