Filtre gaussien avec OpenGL Shaders

Je suis en train d'apprendre les Shaders à mettre en place quelque chose dans mon iPhone. Jusqu'à présent j'ai compris facilement des exemples comme la réalisation d'une image couleur en échelle de gris, de seuillage, etc. La plupart des exemples concernent des opérations simples en cas de traitement d'entrée de pixel de l'image I(x,y) résultats dans une simple modification des couleurs de la même pixel

Mais, comment sur Circonvolutions?. Par exemple, le plus simple exemple, le filtre Gaussien,

dans lesquels la production de pixel de l'image O(x,y) ne dépend pas seulement sur I(x,y) mais aussi sur les environs de 8 pixels.

O(x,y) = (I(x,y)+ surrounding 8 pixels values)/9;

Normalement, cela ne peut être fait avec une seule image de la mémoire tampon d'entrée ou de pixels va changer le filtre est effectué. Comment puis-je faire cela avec des shaders? Aussi, dois-je gérer les frontières de moi-même? ou il y a un construit-il la fonction ou quelque chose que l'enregistrement non valide pixel d'accès comme I(-1,-1) ?

Merci d'avance

PS: je vais être généreux(lire:donner beaucoup de points) 😉

source d'informationauteur nacho4d

  1. 8

    Hautement optimisé shader approche fondée sur l'exécution de l'un à neuf frappé flou Gaussien a été présenté par Daniel Rákos. Son processus utilise le sous-jacent d'interpolation fournis par filtrage de texture dans le matériel pour effectuer une période de neuf frappé filtre à l'aide de seulement cinq texture de lectures par passer. C'est également divisée en horizontale et verticale séparées passe à réduire davantage le nombre de texture lectures nécessaires.

    J'ai roulé une mise en œuvre de la présente, à l'écoute pour OpenGL ES et iOS Gpu, en mon framework de traitement d'image (en vertu de la GPUImageFastBlurFilter classe). Dans mes tests, il peut effectuer un seul flou de passer d'une image de 640 x 480 en 2.0 ms sur un iPhone 4, ce qui est assez rapide.

    J'ai utilisé le suivant vertex shader:

     attribute vec4 position;
 attribute vec2 inputTextureCoordinate;

 uniform mediump float texelWidthOffset; 
 uniform mediump float texelHeightOffset; 

 varying mediump vec2 centerTextureCoordinate;
 varying mediump vec2 oneStepLeftTextureCoordinate;
 varying mediump vec2 twoStepsLeftTextureCoordinate;
 varying mediump vec2 oneStepRightTextureCoordinate;
 varying mediump vec2 twoStepsRightTextureCoordinate;

 void main()
 {
     gl_Position = position;

     vec2 firstOffset = vec2(1.3846153846 * texelWidthOffset, 1.3846153846 * texelHeightOffset);
     vec2 secondOffset = vec2(3.2307692308 * texelWidthOffset, 3.2307692308 * texelHeightOffset);

     centerTextureCoordinate = inputTextureCoordinate;
     oneStepLeftTextureCoordinate = inputTextureCoordinate - firstOffset;
     twoStepsLeftTextureCoordinate = inputTextureCoordinate - secondOffset;
     oneStepRightTextureCoordinate = inputTextureCoordinate + firstOffset;
     twoStepsRightTextureCoordinate = inputTextureCoordinate + secondOffset;
 }

    et le fragment shader: 

     precision highp float;

 uniform sampler2D inputImageTexture;

 varying mediump vec2 centerTextureCoordinate;
 varying mediump vec2 oneStepLeftTextureCoordinate;
 varying mediump vec2 twoStepsLeftTextureCoordinate;
 varying mediump vec2 oneStepRightTextureCoordinate;
 varying mediump vec2 twoStepsRightTextureCoordinate;

//const float weight[3] = float[]( 0.2270270270, 0.3162162162, 0.0702702703 );

 void main()
 {
     lowp vec3 fragmentColor = texture2D(inputImageTexture, centerTextureCoordinate).rgb * 0.2270270270;
     fragmentColor += texture2D(inputImageTexture, oneStepLeftTextureCoordinate).rgb * 0.3162162162;
     fragmentColor += texture2D(inputImageTexture, oneStepRightTextureCoordinate).rgb * 0.3162162162;
     fragmentColor += texture2D(inputImageTexture, twoStepsLeftTextureCoordinate).rgb * 0.0702702703;
     fragmentColor += texture2D(inputImageTexture, twoStepsRightTextureCoordinate).rgb * 0.0702702703;

     gl_FragColor = vec4(fragmentColor, 1.0);
 }

    pour effectuer cette. Les deux les passes peuvent être obtenus en envoyant une valeur de 0 pour la texelWidthOffset (pour la verticale passe), puis de les nourrir que le résultat d'une course où vous donnez une valeur de 0 pour la texelHeightOffset (à l'horizontale).

    J'ai aussi quelques exemples plus avancés de circonvolutions dans l'au-dessus-relié-cadre, y compris Sobel détection de bord.

  2. 2

    Flou Horizontal à l'aide de l'avantage de la méthode d'interpolation bilinéaire. Flou Vertical pass est analogique. Déroulez pour optimiser.

    //5 offsets for 10 pixel sampling!
float[5] offset = [-4.0f, -2.0f, 0.0f, 2.0f, 4.0f];
//int[5] weight = [1, 4, 6, 4, 1]; //sum = 16
float[5] weightInverse = [0.0625f, 0.25f, 0.375, 0.25f, 0.0625f];

vec4 finalColor = vec4(0.0f);

for(int i = 0; i < 5; i++)
    finalColor += texture2D(inputImage, vec2(offset[i], 0.5f)) * weightInverse[i];