Question

我想创建一种使用3x3高斯内核模糊24位图像的方法。

我得到了以下的东西。

3x3高斯内核：

A是原始图像，B是生成的图像。

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)

方法：

public static BufferedImage gaussianBlur(Image img)

其中img是输入图像的参考变量返回值是结果图像的对象的地址。

我应该将图像分成9个部分来实现这个方法吗？

Answer 1

您无需将其分为9个部分。至少，我认为没有充分理由这样做。

但是在这个过程中你最好小心，记得将图像数据复制到某个地方并始终使用这些数据来计算新图像，避免使用新的图像数据来计算新图像。

另外，我不明白为什么你需要编写自己的函数来高斯模糊图像。这可以很容易地完成如下：

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);

Answer 2

不要将其分成几部分。如果你有大图像怎么办？你应该做的是先写一个函数，检查过滤器是否在图像范围内。 C中的 会是这样的：

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;
}

而不是写单独的函数来计算强度：

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;
}

然后只需编写applyFilter m2是您需要旋转180度的过滤器。 Matrix applyFilter（Matrix m1，Matrix m2）{ int x，y; //首先旋转过滤器 Matrix rotFilter = createMatrix（m2.height，m2.width）; for（x = 0; x＆lt; m2.height; x ++） for（y = 0; y＆lt; m2.width; y ++）{ rotFilter.map [y] [x] = m2.map [m2.height-y-1] [m2.width-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;
}

这是一种必须修改以适应java数据结构的一般方法，但算法是相同的。

使用3x3高斯内核模糊图像？

2 个答案: