Apache flex 为什么Pixel Bender过滤器在Toolkit中的行为与Flex/Air应用程序中的行为不同？

好的，我试过这个更简单的过滤器，空气代码如下：

<languageVersion : 1.0;>

kernel NewFilter
<   namespace : "Your Namespace";
    vendor : "Your Vendor";
    version : 1;
    description : "your description";
>
{
    input image4 src;
    output pixel4 dst;

    void
    evaluatePixel()
    {
        pixel4 cPix  = sampleNearest(src,outCoord());
        pixel3 RGB = cPix .rgb;
        float r = RGB.r; 
        float g = RGB.g; 
        float b = RGB.b;
        //float minVal = min(r, g); 
        dst = pixel4(r, g, b, 1);
    }
}

我正在尝试为flex应用程序制作pixel bender过滤器，它将输入图像的色调值的选定范围更改为定义的新色调值。 我在Pixel bender工具箱中制作了这样的过滤器，并给出了令人满意的结果

这是该过滤器的代码：

<languageVersion : 1.0;>

kernel ColorChange
<   namespace : "Your Namespace";
    vendor : "Your Vendor";
    version : 1;
    description : "your description";
>
{
    input image4 src;
    output pixel4 dst;

    parameter float HUE
    <
        minValue: 0.;
        maxValue: 359.9;
        defaultValue: 0.;
    >;
    parameter float SAT
    <
        minValue: -1.;
        maxValue: 1.;
        defaultValue: 0.;
    >;
    parameter float VAL
    <
        minValue: -1.;
        maxValue: 1.;
        defaultValue: 0.;
    >;

    parameter float MIN_RANGE
    <
        minValue: 0.;
        maxValue: 360.;
        defaultValue: 0.;
    >;

    parameter float MAX_RANGE
    <
        minValue: 0.;
        maxValue: 360.;
        defaultValue: 360.;
    >;

    void
    evaluatePixel()
    {
        pixel4 cPix = sample(src,outCoord());
        pixel3 RGB = cPix.rgb;
        float3 HSV;
        //--------------------------------------------------------------
        // CONVERT RGB TO HSV
        //--------------------------------------------------------------
        pixel1 r = RGB.r; 
        pixel1 g = RGB.g; 
        pixel1 b = RGB.b;

        pixel1 minVal = min(min(r, g), b); 
        pixel1 maxVal = max(max(r, g), b);
        pixel1 delta = maxVal - minVal;
        HSV[2] = maxVal;
        if (maxVal == 0.) {
            HSV[0] = 0.;
            HSV[1] = 0.;
        } 
        else
        {
            HSV[1] = delta / maxVal;
        }

        if(r == maxVal)
            HSV[0] = (g-b)/delta;
        else if(g == maxVal)
            HSV[0] = 2. + (b-r) / delta;
        else
            HSV[0] = 4. + (r-g) / delta;

        HSV[0] *= 60.;
        if(HSV[0] <0.)
            HSV[0] += 360.;

        //--------------------------------------------------------------
        // FILTER RANGE OF HUE
        //--------------------------------------------------------------
        if((HSV[0] < MIN_RANGE) || (HSV[0] > MAX_RANGE))
        {
            dst = cPix;
        }
        else
        {
            //--------------------------------------------------------------
            // CHNAGE HSV
            //--------------------------------------------------------------
            float hH = HUE;
            float sS = SAT;
            float vV = VAL;
            HSV[0] = HUE;
            HSV[1] += SAT;
            if(HSV[1] > 1.)
                HSV[1] = 1.;
            else if(HSV[1] < 0.)
                HSV[1] = 0.;
            HSV[2] += VAL;
                if(HSV[2] > 1.)
                    HSV[2] = 1.;
                else if(HSV[2] < 0.)
                    HSV[2] = 0.;
            //----------------------------------------------------------------------
            // CONVERT HSV TO RGB
            //----------------------------------------------------------------------
            float h = HSV[0];// / 360.; 
            float s = HSV[1];// / 100. * 255.; 
            float v = HSV[2];// / 100. * 255.;

            if (s == 0.) {
                RGB.r = v;
                RGB.g = v;
                RGB.b = v;
            } else {
                h = h / 60.;
                int var_i = int(floor(h));
                float f = h - float(var_i);
                float p = v * (1.-s);
                float q = v * (1.-s*f);
                float t = v * (1.-s*(1.-f));
                if (var_i == 0) {
                    RGB.r = v; 
                    RGB.g = t; 
                    RGB.b = p;
                }
                else if (var_i == 1) {
                    RGB.r = q; 
                    RGB.g = v; 
                    RGB.b = p;
                }
                else if (var_i == 2) {
                    RGB.r = p; 
                    RGB.g = v; 
                    RGB.b = t;
                }
                else if (var_i == 3) {
                    RGB.r = p; 
                    RGB.g = q; 
                    RGB.b = v;
                }
                else if (var_i == 4) {
                    RGB.r = t; 
                    RGB.g = p; 
                    RGB.b = v;
                }
                else {
                    RGB.r = v; 
                    RGB.g = p; 
                    RGB.b = q;
                }
            }
            dst = pixel4(RGB.r, RGB.g, RGB.b, 1);
        }
    }
}

内核颜色变化
<名称空间：“您的名称空间”；
供应商：“您的供应商”；
版本：1；
描述：“你的描述”；
>
{
输入image4src；
输出像素4dst；
参数浮动色调
<
最小值：0。；
最大值：359.9；
默认值：0。；
>;
参数浮点SAT
<
最小值：-1。；
最大值：1。；
默认值：0。；
>;
参数浮点值
<
最小值：-1。；
最大值：1。；
默认值：0。；
>;
参数浮动最小值范围
<
最小值：0。；
最大值：360。；
默认值：0。；
>;
参数浮动最大值范围
<
最小值：0。；
最大值：360。；
默认值：360。；
>;
无效的
evaluatePixel（）
{
pixel4 cPix=样本（src，outCoord（））；
pixel3 RGB=cPix.RGB；
3型单纯疱疹病毒；
//--------------------------------------------------------------
//将RGB转换为HSV
//--------------------------------------------------------------
pixel1r=RGB.r；
像素1 g=RGB.g；
pixel1b=RGB.b；
pixel1 minVal=min（min（r，g），b）；
像素1最大值=最大值（最大值（r，g），b）；
像素1增量=最大值-最小值；
HSV[2]=maxVal；
如果（maxVal==0。）{
HSV[0]=0。；
HSV[1]=0。；
} 
其他的
{
HSV[1]=增量/最大值；
}
if（r==maxVal）
HSV[0]=（g-b）/delta；
else if（g==maxVal）
HSV[0]=2.+（b-r）/delta；
其他的
HSV[0]=4.+（r-g）/delta；
HSV[0]*=60。；
if（HSV[0]最大_范围））
{
dst=cPix；
}
其他的
{
//--------------------------------------------------------------
//技术单纯疱疹病毒
//--------------------------------------------------------------
浮动hH=色调；
浮动sS=SAT；
浮动vV=VAL；
HSV[0]=色调；
HSV[1]+=SAT；
如果（HSV[1]>1.）
HSV[1]=1。；
否则，如果（HSV[1]<0.）
HSV[1]=0。；
HSV[2]+=VAL；
如果（HSV[2]>1.）
HSV[2]=1。；
否则，如果（HSV[2]<0.）
HSV[2]=0。；
//----------------------------------------------------------------------
//将HSV转换为RGB
//----------------------------------------------------------------------
浮点h=HSV[0]；///360。；
浮点数s=HSV[1]；///100.*255。；
浮点v=HSV[2]；///100.*255。；
如果（s==0。）{
RGB.r=v；
RGB.g=v；
RGB.b=v；
}否则{
h=h/60。；
int var_i=int（楼层（h））；
浮点数f=h——浮点数（var_i）；
浮点数p=v*（1.-s）；
浮点数q=v*（1.-s*f）；
浮点数t=v*（1.-s*（1.-f））；
如果（var_i==0）{
RGB.r=v；
RGB.g=t；
RGB.b=p；
}
else if（var_i==1）{
RGB.r=q；
RGB.g=v；
RGB.b=p；
}
else if（var_i==2）{
RGB.r=p；
RGB.g=v；
RGB.b=t；
}
else if（var_i==3）{
RGB.r=p；
RGB.g=q；
RGB.b=v；
}
否则，如果（var_Ui==4）{
RGB.r=t；
RGB.g=p；
RGB.b=v；
}
否则{
RGB.r=v；
RGB.g=p；
RGB.b=q；
}
}
dst=像素4（RGB.r，RGB.g，RGB.b，1）；
}
}
}

所以原理很简单，将每个像素转换为HSV颜色空间，检查色调是否在选定范围内，如果它确实将其色调更改为定义的色调，然后转换回RGB

问题是，当在Air应用程序中使用时，从只使用过滤器的默认参数开始，我并没有得到相同的结果

这是空气应用的代码：

<?xml version="1.0" encoding="utf-8"?>
<s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009"
                       xmlns:s="library://ns.adobe.com/flex/spark"
                       width="1400" height="800" backgroundAlpha="0.0" xmlns:mx="library://ns.adobe.com/flex/mx" 
                       creationComplete="windowedapplication1_creationCompleteHandler(event)">
    <fx:Declarations>
        <!-- Place non-visual elements (e.g., services, value objects) here -->
    </fx:Declarations>

    <fx:Script>
        <![CDATA[
            import mx.events.ColorPickerEvent;
            import mx.events.FlexEvent;

            import spark.filters.ShaderFilter;
            import spark.utils.BitmapUtil;

            [Embed(source="myFilter.pbj", mimeType="application/octet-stream")]
            private var MyBender:Class;

            private var shader:Shader = new Shader();
            private var shaderJob:ShaderJob;
            private var shaderResult:BitmapData;


            private function filter():void
            {                       
                // Configure desired input parameters of shader.
                shader.data.src.input = originalImage.bitmapData;

//              shader.data.HUE.value = [H_slider.value];
//              shader.data.SAT.value = [S_slider.value];
//              shader.data.VAL.value = [V_slider.value];
//              shader.data.MAX_RANGE.value = [H_max_slider.value];
//              shader.data.MIN_RANGE.value = [H_min_slider.value];

                shaderJob = new ShaderJob(shader, shaderResult);
                shaderJob.start(true);
                bendedImage.source = new Bitmap(shaderResult);
            }

            private function windowedapplication1_creationCompleteHandler(event:FlexEvent):void
            {
                // Create new shader instance and initialize with embedded byte code.
                shader = new Shader(new MyBender());
                shaderResult = new BitmapData(originalImage.width, originalImage.height);
                filter();
            }

        ]]>
    </fx:Script>
    <s:HGroup width="100%">
        <s:Group id="originalGroup" width="100%">
            <s:Image id="originalImage" source="mandelbrot.png"/>
        </s:Group>
        <s:Group id="bendedGroup" width="100%">
            <s:SWFLoader id="bendedImage" source="mandelbrot.png" />
            <s:HSlider id="H_slider" minimum="0" maximum="359.9" stepSize="0.1" value="0" change="filter()" width="500" toolTip="HUE"/>
            <s:HSlider id="S_slider" minimum="-1" maximum="1" stepSize="0.1" value="0" y="20" change="filter()" width="500" toolTip="SAT"/>
            <s:HSlider id="V_slider" minimum="-1" maximum="1" stepSize="0.1" value="0" y="40" change="filter()" width="500" toolTip="VAL"/>
            <s:HSlider id="H_max_slider" minimum="0" maximum="360" stepSize="0.1" value="360" y="60" change="filter()" width="500" toolTip="HUE MAX"/>
            <s:HSlider id="H_min_slider" minimum="0" maximum="360" stepSize="0.1" value="0" y="80" change="filter()" width="500" toolTip="HUE MIN"/>
        </s:Group>
    </s:HGroup> 
</s:WindowedApplication>

因此，使用默认参数在Air app中应用PixelBender过滤器会产生以下结果：

http://i.stack.imgur.com/UyoZR.png

但在Pixel Bender Toolkit中，我看到了相同的参数：

http://i.imgur.com/LNnCi.png

更改应用程序中的“色调最大值”滑块（绑定到过滤器的“最大值范围”参数），它不会平滑地过滤掉色调值，而是在“色调最大值”为59.9时设置阈值，在较低的值时，看起来没有应用过滤器；在“色调最大值”为299.9时，介于60和299.9之间的值如下所示：

if (maxVal == 0.) 

http://i.stack.imgur.com/5kePu.png

（对不起，新用户）

---

你知道我做错了什么吗？

你的PB代码中有很多浮点比较。像这样的台词：

if (maxVal == 0.) 

外部易受舍入误差的影响。我建议改用这样的方式：

if (abs(maxVal) < epsilon) 

if（abs（maxVal）

您的AS代码中有注释掉的设置参数值的行。你能试试com吗

pixel1 minVal = r;
if(g < minVal)
minVal = g;
if(b < minVal)
minVal = b;

pixel1 minVal = min(min(r, g), b);