Comment mettre en œuvre une boîte ou un flou gaussien sur iOS

Je veux être en mesure de prendre une image et flou assez rapidement (par exemple en 0.1 sec). La taille de l'Image serait presque jamais être supérieure à 256 x 256 px.

Dois-je loop thru chaque pixel et la moyenne avec les voisins ou est-il un niveau supérieur que je puisse faire cela?

PS: je suis conscient que plusieurs zone de flou peut se rapprocher d'un flou gaussien.

InformationsquelleAutor willc2 | 2009-07-16
  1. 35

    Je l'ai trouvé vraiment très rapide assez merdique moyen pour iOS3.2+ apps

      UIView *myView = [self view];
  CALayer *layer = [myView layer];
  [layer setRasterizationScale:0.25];
  [layer setShouldRasterize:YES];

    Ce pixellise l'on a une vue 4x4 pixels morceaux puis les échelles vers le haut à l'aide de filtrage bilinéaire... il est EXTRÊMEMENT rapide et semble ok si vous avez envie d'un flou d'arrière-plan de la vue sous un modal vue.

    L'annuler, il suffit de régler le tramage à l'échelle de retour à 1,0 ou désactiver la pixellisation.

    • très soigné solution! Il a travaillé pour moi pendant une UIImageView.
    • En effet, une solution élégante! J'ai remarqué quelque chose d'étrange à tout récemment - Si je ne puissances de 1/2 le flou est grande sur le simulateur, mais sur le périphérique-je obtenir une marge apparaissant sur le côté - n'importe qui-il un avis? 10x!
    • Pouvez-vous m'aider avec cette question: "Effet de Flou (mouillé sur Mouillé effet) dans l'Application de Peinture en Utilisant OpenGL-ES" stackoverflow.com/questions/6980402/...
    • J'ai utilisé ce sur les étiquettes, trop. Excellente ressource!
    • J'aime creative solutions de contournement comme ça. Très élégant!
    • Veuillez noter que le flou sera différent sur la rétine/nonretina appareils. Vous devez multiplier 0.25 par [[UIScreen écran principal] scale] pour le faire paraître la même pour toutes les densités de pixels.
    • C'est plus rapide que de coutume flou de mise en œuvre que j'ai vu!
    • Pouvez pas appeler à l'effet de flou !

    InformationsquelleAutor Gabe
  2. 5

    De how-do-i-créer-floue-texte-dans-un-iphone-vue:

    Prendre un coup d'oeil à Apple GLImageProcessing iPhone échantillon. Il fait un peu flou, entre autres choses.

    Le code comprend:

    static void blur(V2fT2f *quad, float t) //t = 1
{
GLint tex;
V2fT2f tmpquad[4];
float offw = t / Input.wide;
float offh = t / Input.high;
int i;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex);
//Three pass small blur, using rotated pattern to sample 17 texels:
//
//.\/.. 
//./\\/
//\/X/\   rotated samples filter across texel corners
///\\/. 
//../\. 
//Pass one: center nearest sample
glVertexPointer  (2, GL_FLOAT, sizeof(V2fT2f), &quad[0].x);
glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f(1.0/5, 1.0/5, 1.0/5, 1.0);
validateTexEnv();
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
//Pass two: accumulate two rotated linear samples
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
for (i = 0; i < 4; i++)
{
tmpquad[i].x = quad[i].s + 1.5 * offw;
tmpquad[i].y = quad[i].t + 0.5 * offh;
tmpquad[i].s = quad[i].s - 1.5 * offw;
tmpquad[i].t = quad[i].t - 0.5 * offh;
}
glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &tmpquad[0].x);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glActiveTexture(GL_TEXTURE1);
glEnable(GL_TEXTURE_2D);
glClientActiveTexture(GL_TEXTURE1);
glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &tmpquad[0].s);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glBindTexture(GL_TEXTURE_2D, tex);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB,         GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB,     GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_PRIMARY_COLOR);
glColor4f(0.5, 0.5, 0.5, 2.0/5);
validateTexEnv();
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
//Pass three: accumulate two rotated linear samples
for (i = 0; i < 4; i++)
{
tmpquad[i].x = quad[i].s - 0.5 * offw;
tmpquad[i].y = quad[i].t + 1.5 * offh;
tmpquad[i].s = quad[i].s + 0.5 * offw;
tmpquad[i].t = quad[i].t - 1.5 * offh;
}
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
//Restore state
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, Half.texID);
glDisable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB,     GL_SRC_ALPHA);
glActiveTexture(GL_TEXTURE0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glDisable(GL_BLEND);
}
    InformationsquelleAutor mahboudz
  3. 4

    Si vous avez toujours ou au moins utilisent souvent le même flou paramètres susceptibles de gagner de la vitesse en faisant le filtrage dans le domaine fréquentiel au lieu de le domaine spatial.

    1. Precaclulate votre filtre d'image G(u,v), qui est un 2D gaussien
    2. Appliquer la transformée de fourier à votre image d'entrée f(x,y)->F(u,v)
    3. Filtre par la multiplication: H(u,v) = F(u,v) .* G(u,v) (pixelwise multiplication, pas de multiplication de matrice)
    4. Transformer votre image filtrée en arrière dans le domaine spatial par transformée de fourier inverse: H(u,v) -> h(x,y)

    Les avantages de cette approche est que pixel-sage de multiplication doit être assez rapide par rapport à la moyenne d'un quartier. Donc, si vous traiter un lot d'images ce qui pourrait aider.

    L'inconvénient est que je n'ai aucune idée à quelle vitesse vous pouvez faire des transformées de fourier sur l'iPhone donc cela peut très bien être beaucoup plus lent que les autres implémentations.

    Autre que cela, je suppose que depuis l'iPhone a le support OpenGL, vous pourriez peut-être utiliser ses texturing/fonctions de dessin à faire. Désolé de le dire, bien que je ne suis pas OpenGL expert et ne peut pas vraiment donner tous les conseils pratiques que la façon dont cela est fait.

    InformationsquelleAutor Hannes Ovrén
  4. 3

    Voici deux astuces pour homme pauvre flou:

    1. Prendre l'image, un tirage au sort à une opacité partielle 5 ou 6 (ou cependant de beaucoup que vous voulez) fois chaque fois offseting par un couple de pixels dans une direction différente. dessin fois de plus en plus de directions vous obtient une meilleure flou, mais de toute évidence vous en échange de temps de traitement. Cela fonctionne bien si vous voulez un effet de flou avec un relativement petit rayon.

    2. Pour des images monochromatiques, vous pouvez réellement utiliser le construire dans l'ombre comme un simple flou.

    • Si le "une opacité partielle" est un Gaussin courbe en cloche de la fonction de "couple de pixels," vous avez la définition d'un flou gaussien (moins d'aliasing questions).
    • Savez-vous à quelle vitesse les multiples dessins pour un 4-way flou? C'est, 4 à gauche et 4 à droite.
    InformationsquelleAutor amattn
  5. 2

    Vous voudrez peut-être jeter un coup d'oeil à Mario Klingemann de StakBlur algorithme. Ce n'est pas Gaussienne, mais assez proche.

    • Puis-je utiliser un CGImageRef titre de contribution à l'StackBlur? Vous ne savez pas où je reçois les données de pixel de.
    InformationsquelleAutor balpha
  6. 1

    N'importe quel algorithme qui modifys images sur un pixel de niveau via openGL va être un peu lent; pixel-par-pixel manipulation sur une texture openGL et puis la mise à jour à chaque image est malheureusement performance adéquate.

    Passer un peu de temps à écrire un banc d'essai et l'expérimentation avec la manipulation de pixels avant de s'engager à la mise en œuvre d'un complexe de flou de routine.

    InformationsquelleAutor Phill
  7. 0

    Les principes de base de l'effet de flou (ou peut-être plus d'un ramollir), est en moyenne de 2 pixels voisins, et d'appliquer la moyenne de deux pixels. parcourir cette tout au long de l'image, et vous obtenez un léger flou de bougé (adoucir).

    InformationsquelleAutor GeneCode