Le flou d'une image à l'aide de 3x3 noyau Gaussien?

Je veux créer une méthode pour brouiller les 24 bits de l'image à l'aide de 3x3 noyau Gaussien.

M'a donné les choses suivantes.

Le 3x3 noyau Gaussien:

Le flou d'une image à l'aide de 3x3 noyau Gaussien?

Une est l'image d'origine et de B est l'image qui en résulte.

B(i,j) =
1/16 * A(i-1,j-1) +1/8 * A(i,j-1) +1/16 * A(i+1,j-1) +1/8 * A(i-1,j) +1/4 * A(i,j) +1/8 *A(i+1,j) +1/16 * A(i-1,j+1) +1/8 * A(i,j+1) +1/16 * A(i+1,j+1)

La méthode:

public static BufferedImage gaussianBlur(Image img)

où img est une variable de référence d'une image d'entrée.
La valeur retournée est une adresse d'un objet de l'image résultante.

Dois-je en divisant l'image en 9 parties pour mettre en œuvre cette méthode?

Pourquoi voudriez-vous faire cela?
Ce que vous avez à prendre en compte est d'utiliser les anciennes valeurs de l'image et non pas les nouveaux.

OriginalL'auteur Taylor | 2013-12-23

  1. 10

    Vous n'avez pas besoin de diviser pour 9 parties. Au moins, je ne vois pas de bonnes raisons pour ce faire.

    Mais vous feriez mieux d'être prudent au cours de ce processus, n'oubliez pas de copier les données d'image à quelque part, et toujours utiliser ces données pour le calcul de la nouvelle image, éviter d'utiliser les nouvelles données de l'image à calculer la nouvelle image.

    Aussi, je ne comprends pas pourquoi vous avez besoin d'écrire votre propre fonction pour Gaussien flou d'une image. Cela peut facilement être fait comme suit:

    float[] matrix = {
    1/16f, 1/8f, 1/16f, 
    1/8f, 1/4f, 1/8f, 
    1/16f, 1/8f, 1/16f, 
};

BufferedImageOp op = new ConvolveOp( new Kernel(3, 3, matrix) );
blurredImage = op.filter(sourceImage, destImage);

    OriginalL'auteur herohuyongtao

  2. 0

    Ne pas la diviser en plusieurs parties. que faire si vous avez de grandes images.
    ce que vous devez faire est de commencer par écrire une fonction qui vérifie si le filtre est à l'intérieur de l'image de limites. en C, il serait quelque chose comme ceci:

    int filterWithinImage(Matrix m1, Matrix m2, int i, int j) {
  int b; //min number of pixels that the center of the filter needs to be
         //away from any border of the image to be inbounds


  /***********************odd size filter only*************************/
  //when filter size is odd there is well defined convenient center
  //of the filter
  if (isOdd(m2.height) && isOdd(m2.width)) {
    //to check the bounds subtract 1 from the width and divide by 2
    b = (m2.width - 1) / 2;
    //look at the left border
    if ((j - b)<0) return 0;
    //top border
    if ((i - b)<0) return 0;
    //right border
    if ((j + b)>(m1.width-1)) return 0;
    //bottom border
    if ((i + b)>(m1.height -1)) return 0;
  }
  return 1;
}

    que d'écrire une fonction pour calculer les intensités:

    double calculateValue(Matrix m1,Matrix m2,int imagei, int imagej) {
  double out = 0;//return value
  int i, j, fli, flj; //for iterating over the filter
  int b = (m2.height -1) / 2;//max number that we add to the center coordinates
                            //to get to the edge of the filter
  fli = 0; flj = 0;
  for(i = imagei - b; i < imagei + b +1; i++) {
    for(j = imagej - b; j < imagej + b +1; j++) {
          //   if (i == 599)
      //printf("calc func image i: %d,  image j %d, b %d,  filter i %d,  filter j %d\n",
      //i,j,b,fli,flj);      
      out += m1.map[i][j] * m2.map[fli][flj++];
    }
    fli++;
    flj=0;
  }
  return out;
}

    alors il suffit d'écrire applyFilter
    m2 est le filtre que vous devez faire pivoter de 180 degrés.
    Matrice applyFilter(la Matrice m1, la Matrice m2) {
    int x,y;
    //pivoter le filtre première
    Matrice rotFilter = createMatrix(m2.hauteur de,m2.la largeur);
    for (x = 0; x < m2.hauteur; x++)
    for (y = 0; y < m2.largeur; y++) {
    rotFilter.carte[y][x] = m2.carte[m2.hauteur-y-1][m2.largeur-x-1];
    }

      Matrix mOut = createMatrix(m1.height, m1.width);
  int i,j;
  for (i = 0; i < m1.height; i++) {
    for (j = 0; j < m1.width; j++) {
      if (!filterWithinImage(m1,rotFilter,i,j)) { //filter is out of bounds
    mOut.map[i][j] = 0;
      }
      else {
    mOut.map[i][j] = calculateValue(m1,rotFilter,i,j);
      }
    }
  }
  return mOut;
}

    c'est une approche générale qui aurait modifié pour s'adapter à java structures de données, mais les algorithmes de calculs sont les mêmes.

    OriginalL'auteur A_P