Can PB can calcute the bounding box as the needed region in AE?

Question

Hi,
I wrote many small pixel bender that I use mainly in AE. However I need them to be as efficient as possible, so I wonder if Pixel Bender can obtain the bounding box of an image input as the needed region. This way, it will not calculate an entire frame when there is only a few pixels in the frame.
Thanks
Jocelyn Tremblay

Answer 1

Hi,
I did a major breakthrough by rethinking the model. Now I get a real speed improvment, and if the image is fully opaque, there is not too much drawback.
Instead of a simple bounding box, I'm creating a grid in which each cell represent a region of the source and is float4(1). if there is any non-zero transparent pixel. In the last kernel of the graph, i'm processing only when the corresponding value in the grid is float4(1.). I get really efficient results from that. I'm including two graphs. A basic one with a fixed grid of 16px (I didn't do any beanchmark for the grid size) where I output the original image composited over the scaled grid in green. The second one, where the last kernel is a box blur, the grid size equal the blur radius, and there is a convolution kernel between the grid and the box blur that expand the grid to fit the blur.
GridExperience.pbg
<?xml version="1.0" encoding="utf-8"?>
<graph name = "GridExperience" xmlns="http://ns.adobe.com/PixelBenderGraph/1.0">
    <metadata name = "namespace" value =  "com.jocelyntremblay"/>
    <metadata name = "vendor" value = "Jocelyn Tremblay" />
    <metadata name = "version" type = "int" value = "1" />
    <!-- Image inputs and outputs of the graph -->
    <inputImage type = "image4" name = "src" />
    <outputImage type = "image4" name = "dst" />
    <!-- Graph parameters -->
    <parameter type="float2" name="sourceSize" >
        <metadata name="minValue" type="float2" value="1"/>
        <metadata name="maxValue" type="float2" value="4096" />
        <metadata name="defaultValue" type="float2" value="634., 396." />
        <metadata name="aeUIControl" value="aePoint" />
        <metadata name="aePointRelativeDefaultValue" type="float2" value="1, 1" />
    </parameter>
        <!-- Graph parameters -->
    <parameter type="float" name="gridSize" >
        <metadata name="minValue" type="float" value="1"/>
        <metadata name="maxValue" type="float" value="64" />
        <metadata name="defaultValue" type="float" value="16" />
    </parameter>
     <!-- Embedded kernel -->
     <kernel>
      <![CDATA[
         <languageVersion : 1.0;>
         kernel getProcessingGrid
         <  
            namespace:"com.jocelyntremblay";
            vendor:"Jocelyn Tremblay";
            version:1;
         >{
            input image4 src;
            output float4 dst;
            parameter float2 sourceSize
            <
                parameterType : "inputSize";
                inputSizeName : "src";
            >;
            parameter float gridSize
            <
                minValue:float(1.0);
                maxValue:float(64.0);
                defaultValue:float(5.0);
            >;
            region changed(region inputRegion, imageRef inputIndex){
                return region(float4(0, 0, ceil(sourceSize.x/gridSize), ceil(sourceSize.y/gridSize)));
            void evaluatePixel(){
                float j;
                float4 pix;
                dst = float4(0.0);
                for (float i = 0.; i < gridSize; i++){
                    j = 0.;
                    for (j; j < gridSize; j++){
                        pix = sampleNearest(src, float2(floor(outCoord().x) * gridSize + i, floor(outCoord().y) * gridSize + j));
                        if (pix.a > 0.){
                            dst = float4(1.0);
                            i = j = gridSize;
      ]]>
     </kernel>
     <kernel>
      <![CDATA[
         <languageVersion : 1.0;>
         kernel drawProcessingGrid
         <  
            namespace:"com.jocelyntremblay";
            vendor:"Jocelyn Tremblay";
            version:1;
         >{
            input image4 src;
            input image4 processingGrid;
            output float4 dst;
            parameter float gridSize
            <
                minValue:float(1.0);
                maxValue:float(64.0);
                defaultValue:float(5.0);
            >;
            void evaluatePixel(){
                float4 gridSegment = sampleNearest(processingGrid, float2(floor(outCoord().x/gridSize), floor(outCoord().y/gridSize)));
                if (gridSegment.a > 0.){
                                //process
                                dst = float4(0., 1., 0., 1.);
                                float4 tt = sampleNearest(src, outCoord());
                                if(tt.a > 0.){
                                    dst.rgb = tt.rgb;
                else{
                    //do not process
                    dst = float4(0.);
      ]]>
     </kernel>
    <!-- Instances of the nodes -->
    <node id = "getProcessingGrid" name ="getProcessingGrid" namespace = "com.jocelyntremblay" vendor = "Jocelyn Tremblay" version ="1">
    <evaluateParameters>
            <![CDATA[void evaluateParameters() {
                getProcessingGrid::gridSize = gridSize;
                getProcessingGrid::sourceSize = sourceSize;
            }]]>
        </evaluateParameters>
    </node>
    <node id = "drawProcessingGrid" name ="drawProcessingGrid" namespace = "com.jocelyntremblay" vendor = "Jocelyn Tremblay" version ="1">
    <evaluateParameters>
            <![CDATA[void evaluateParameters() {
                drawProcessingGrid::gridSize = gridSize;
            }]]>
        </evaluateParameters>
    </node>
    <!-- Connect the graph -->
    <connect fromImage = "src" toNode = "getProcessingGrid" toInput = "src" />
    <connect fromImage = "src" toNode = "drawProcessingGrid" toInput = "src" />
    <connect fromNode = "getProcessingGrid" fromOutput = "dst" toNode = "drawProcessingGrid" toInput = "processingGrid" />
    <connect fromNode = "drawProcessingGrid" fromOutput = "dst" toImage = "dst" />
</graph>
GridExperienceBoxBlur.pbg
<?xml version="1.0" encoding="utf-8"?>
<graph name = "GridExperienceBoxBlur" xmlns="http://ns.adobe.com/PixelBenderGraph/1.0">
    <metadata name = "namespace" value =  "com.jocelyntremblay"/>
    <metadata name = "vendor" value = "Jocelyn Tremblay" />
    <metadata name = "version" type = "int" value = "1" />
    <!-- Image inputs and outputs of the graph -->
    <inputImage type = "image4" name = "src" />
    <outputImage type = "image4" name = "dst" />
    <!-- Graph parameters -->
    <parameter type="float2" name="sourceSize" >
        <metadata name="minValue" type="float2" value="1"/>
        <metadata name="maxValue" type="float2" value="4096" />
        <metadata name="defaultValue" type="float2" value="1920., 720." />
        <metadata name="aeUIControl" value="aePoint" />
        <metadata name="aePointRelativeDefaultValue" type="float2" value="1, 1" />
    </parameter>
    <parameter type="float" name="blurRadius" >
        <metadata name="minValue" type="float" value="0"/>
        <metadata name="maxValue" type="float" value="25" />
        <metadata name="defaultValue" type="float" value="5" />
    </parameter>
     <!-- Embedded kernel -->
     <kernel>
      <![CDATA[
         <languageVersion : 1.0;>
         kernel getProcessingGrid
         <  
            namespace:"com.jocelyntremblay";
            vendor:"Jocelyn Tremblay";
            version:1;
         >{
            input image4 src;
            output float4 dst;
            parameter float2 sourceSize
            <
                parameterType : "inputSize";
                inputSizeName : "src";
            >;
            parameter float gridSize
            <
                minValue:float(1.0);
                maxValue:float(64.0);
                defaultValue:float(16.0);
            >;
            region changed(region inputRegion, imageRef inputIndex){
                return region(float4(0, 0,  ceil(sourceSize.x/gridSize), ceil(sourceSize.y/gridSize)));
            void evaluatePixel(){
                float j;
                float4 pix;
                dst = float4(0.0);
                for (float i = 0.; i < gridSize; i++){
                    j = 0.;
                    for (j; j < gridSize; j++){
                        pix = sampleNearest(src, float2(floor(outCoord().x) * gridSize + i, floor(outCoord().y) * gridSize + j));
                        if (pix.a > 0.){
                            dst = float4(1.0);
                            i = j = gridSize;
      ]]>
     </kernel>
     <kernel>
      <![CDATA[
         <languageVersion : 1.0;>
        kernel ConvKernel
        <
        namespace: "After Effects";
        vendor : "Adobe Systems Inc.";
        version : 1;
        description : "Convolves an image using a smoothing mask";
        >
            input image4 source;
            output pixel4 result;
            const float3x3 smooth_mask = float3x3( 1.0, 1.0, 1.0,
            1.0, 1.0, 1.0,
            1.0, 1.0, 1.0);
            const float smooth_divisor = 9.0;
            float4 convolve(float3x3 in_kernel, float divisor) {
                float4 conv_result = float4(0.0, 0.0, 0.0, 0.0);
                float2 out_coord = outCoord();
                for(int i = -1; i <= 1; ++i) {
                    for(int j = -1; j <= 1; ++j) {
                        conv_result += sampleNearest(source,
                        out_coord + float2(i, j)) * in_kernel[i + 1][j + 1];
                conv_result /= divisor;
                return conv_result;
            void evaluatePixel() {
                float4 conv_result = convolve(smooth_mask, smooth_divisor);
                result = conv_result;
            region needed( region output_region, imageRef input_index ) {
                region result = output_region;
                result = outset( result, float2( 1.0, 1.0 ) );
                return result;
            region changed( region input_region, imageRef input_index ) {
                region result = input_region;
                result = outset( result, float2( 1.0, 1.0 ) );
                return result;
        } //kernel ends
        ]]>
      </kernel>
      <kernel>
      <![CDATA[
         <languageVersion : 1.0;>
            kernel BasicBoxBlur
            <   namespace : "AIF";
                vendor : "Adobe Systems";
                version : 2;
                description : "variable Radius Box Blur"; >
            input image4 src;
            input image4 processingGrid;
            output float4 dst;
            parameter float blurRadius
            <
                minValue:float(0.0);
                maxValue:float(25.0);
                defaultValue:float(5.0);
            >;
            dependent int radiusAsInt;
            void evaluateDependents(){
                radiusAsInt = int(ceil(blurRadius));
            parameter float gridSize
            <
                minValue:float(1.0);
                maxValue:float(64.0);
                defaultValue:float(16.0);
            >;
            region needed(region outputRegion, imageRef inputRef){
                float2 singlePixel = pixelSize(src);
                return outset(outputRegion, float2(singlePixel.x * ceil(blurRadius), singlePixel.y * ceil(blurRadius)));
            region changed(region inputRegion, imageRef inputRef){
                float2 singlePixel = pixelSize(src);
                return outset(inputRegion, float2(singlePixel.x * ceil(blurRadius), singlePixel.y * ceil(blurRadius)));
            void evaluatePixel(){
                float4 gridSegment = sampleNearest(processingGrid, float2(floor(outCoord().x/gridSize), floor(outCoord().y/gridSize)));
                if (gridSegment.a > 0.){
                    float denominator = 0.0;
                    float4 colorAccumulator = float4(0.0, 0.0, 0.0, 0.0);             
                    float2 singlePixel = pixelSize(src);
                    for(int i = -radiusAsInt; i <= radiusAsInt; i++)
                        for(int j = -radiusAsInt; j <= radiusAsInt; j++)
                            colorAccumulator += sampleNearest(src,
                                outCoord() + float2(float(i) * singlePixel.x, float(j) * singlePixel.y));
                            denominator++;
                    dst = colorAccumulator / denominator;
                else{
                    //do not process
                    dst = float4(0.);
      ]]>
     </kernel>
    <!-- Instances of the nodes -->
    <node id = "getProcessingGrid" name ="getProcessingGrid" namespace = "com.jocelyntremblay" vendor = "Jocelyn Tremblay" version ="1">
    <evaluateParameters>
            <![CDATA[void evaluateParameters() {
                getProcessingGrid::sourceSize = sourceSize;
                getProcessingGrid::gridSize = max(1., blurRadius);
            }]]>
        </evaluateParameters>
    </node>
    <node id = "ConvKernel" name ="ConvKernel" namespace = "After Effects" vendor = "Adobe Systems Inc." version ="1"></node>
    <node id = "BasicBoxBlur" name ="BasicBoxBlur" namespace = "AIF" vendor = "Adobe Systems" version ="2">
    <evaluateParameters>
            <![CDATA[void evaluateParameters() {
                BasicBoxBlur::blurRadius = blurRadius;
                BasicBoxBlur::gridSize = max(1., blurRadius);
            }]]>
        </evaluateParameters>
    </node>
    <!-- Connect the graph -->
    <connect fromImage = "src" toNode = "getProcessingGrid" toInput = "src" />
    <connect fromImage = "src" toNode = "BasicBoxBlur" toInput = "src" />
    <connect fromNode = "getProcessingGrid" fromOutput = "dst" toNode = "ConvKernel" toInput = "source" />
    <connect fromNode = "ConvKernel" fromOutput = "result" toNode = "BasicBoxBlur" toInput = "processingGrid" />
    <connect fromNode = "BasicBoxBlur" fromOutput = "dst" toImage = "dst" />
</graph>