ConvolutionFilter  - AS3

De alpha-transparantiewaarde van de vervangende kleur. Geldige waarden zijn 0 tot en met 1.0. De standaardwaarde is 0. De waarde .25 stelt bijvoorbeeld een transparantiewaarde in van 25%.

De mate van afwijking die aan het resultaat van de matrixtransformatie moet worden toegevoegd. De afwijking vergroot de kleurwaarde van elk kanaal, zodat donkere kleuren lichter worden weergegeven. De standaardwaarde is 0.

Geeft aan of de afbeelding moet worden vastgeklemd. Voor pixels buiten de bronafbeelding geeft de waarde true aan dat de invoerafbeelding langs de randen wordt vergroot door in de invoerafbeelding de kleurwaarden van elke rand te dupliceren. De waarde false geeft aan dat een andere kleur moet worden gebruikt, zoals opgegeven in de eigenschappen color en alpha. De standaardwaarde is 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);
        }
    }
}

De hexadecimale kleur ter vervanging van pixels buiten de bronafbeelding. Dit is een RGB-waarde zonder alpha-component. De standaardwaarde is 0.

Deler die wordt gebruikt tijdens matrixtransformatie. De standaardwaarde is 1. Een deler die de som van alle matrixwaarden is, spreidt de algemene kleurintensiteit van het resultaat gelijkmatig. De waarde 0 wordt genegeerd en in plaats daarvan wordt de standaardwaarde gebruikt.

Array van waarden die worden gebruikt voor matrixtransformatie. Het aantal items in de array moet gelijk zijn aan matrixX * matrixY.

Een matrixconvolutie wordt gebaseerd op een matrix n x m die beschrijft hoe een bepaalde pixelwaarde in de invoerafbeelding wordt gecombineerd met de naastgelegen pixelwaarden om tot een resulterende pixelwaarde te komen. Elke resulterende pixel wordt bepaald door de matrix toe te passen op de overeenkomstige bronpixel en de naastgelegen pixels.

Voor een 3 x 3 matrixconvolutie wordt de volgende formule gebruikt voor elk onafhankelijk kleurkanaal:

	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
	

Bepaalde filterspecificaties leveren betere prestaties, wanneer ze worden uitgevoerd via een processor met SSE (Streaming SIMD Extensions). Criteria voor snellere convolutiehandelingen zijn:

• Het filter moet een 3 x 3 filter zijn.
• Alle filterwaarden moeten gehele getallen zijn tussen -127 en +127.
• De som van alle filterwaarden kan geen absolute waarde groter dan 127 zijn.
• Wanneer een van de filterwaarden negatief is, moet de deler tussen 2,00001 en 256 liggen.
• Wanneer alle filterwaarden positief zijn, moet de deler tussen 1,1 en 256 liggen.
• De afwijking moet een geheel getal zijn.

Opmerking: wanneer u een instantie ConvolutionFilter maakt met de constructor zonder parameters, beïnvloedt de volgorde waarin u waarden toewijst aan matrix-eigenschappen het gedrag van het filter. In het volgende geval wordt de matrixarray toegewezen terwijl de eigenschappen matrixX en matrixY nog steeds zijn ingesteld op 0 (de standaardwaarde):

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

In het volgende geval wordt de matrixarray toegewezen terwijl de eigenschappen matrixX en matrixY zijn ingesteld op 3:

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

De x-afmetingen van de matrix (het aantal kolommen in de matrix). De standaardwaarde is 0.

De y-afmetingen van de matrix (het aantal rijen in de matrix). De standaardwaarde is 0.

Geeft aan of het alpha-kanaal zonder het filtereffect wordt behouden en of het convolutiefilter zowel op het alpha-kanaal als op de kleurkanalen wordt toegepast. De waarde false geeft aan dat de convolutie op alle kanalen van toepassing is, inclusief het alpha-kanaal. De waarde true geeft aan dat de convolutie alleen op de kleurkanalen van toepassing is. De standaardwaarde is true.

Initialiseert een instantie ConvolutionFilter met de opgegeven parameters.

Retourneert een kopie van dit filterobject.

De functie buildChild() maakt een nieuw object Loader met de naam loader. Voor elke aanroep van buildChild() moet u een gebeurtenislistener aan het object Loader koppelen om naar gebeurtenissen complete te luisteren, die worden afgehandeld door de functie die wordt doorgegeven aan buildChild().

De functies applyBrightness(), applySharpness() enapplyOutline() gebruiken verschillende waarden voor de array matrix om verschillende effecten voor ConvolutionFilter te bereiken.

Opmerking: gebruik voor het beste resultaat een afbeelding van ongeveer 80 pixels breed. De naam en locatie van het afbeeldingsbestand moet overeenkomen met de waarde die u doorgeeft aan de eigenschap url. De waarde die wordt doorgegeven aan url in het voorbeeld verwijst bijvoorbeeld naar een afbeeldingsbestand met de naam Image.jpg dat zich in dezelfde map bevindt als uw SWF-bestand.

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