🍀图片平滑器

描述：

 # 图像平滑器 是大小为 3 x 3 的过滤器，用于对图像的每个单元格平滑处理，平滑处理后单元格的值为该单元格的平均灰度。
 ​
 # 每个单元格的  平均灰度 定义为：该单元格自身及其周围的 8 个单元格的平均值，结果需向下取整。（即，需要计算蓝色平滑器中 9 个单元格的平均值）。
 ​
 # 如果一个单元格周围存在单元格缺失的情况，则计算平均灰度时不考虑缺失的单元格（即，需要计算红色平滑器中 4 个单元格的平均值）。

思考：

我的方法好笨，就是单纯的判断周围数是否存在，是就加上去，不存在就不加。

实现：

 package cn.edu.gzhu.array.imageSmoother;
 ​
 class Solution {
     public int[][] imageSmoother(int[][] img) {
 ​
         int m = img.length;
         int n = img[0].length;
         int index, counter;
 ​
         for (int i = 0; i < m; i++) {
             for (int j = 0; j < n; j++) {
                 index = img[i][j];
                 counter = 1;
                 if (i > 0 && j > 0) {
                     index += img[i - 1][j - 1];
                     counter++;
                 }
                 if (i > 0) {
                     index += img[i - 1][j];
                     counter++;
                 }
                 if (j > 0) {
                     index += img[i][j - 1];
                     counter++;
                 }
                 if (i < m - 1 && j < n - 1) {
                     index += img[i + 1][j + 1];
                     counter++;
                 }
                 if (i < m - 1) {
                     index += img[i + 1][j];
                     counter++;
                 }
                 if (j < n - 1) {
                     index += img[i][j + 1];
                     counter++;
                 }
                 if(i > 0 && j < n-1) {
                     index += img[i - 1][j + 1];
                     counter++;
                 }
                 if(i < m-1 && j > 0) {
                     index += img[i + 1][j - 1];
                     counter++;
                 }
                 img[i][j] = index/counter;
             }
         }
         return img;
     }
 }
 ​

测试一下！

大佬的代码：

看大佬说，这是深度学习padding和卷积。码一下这个题，学了深度学习再回来做！

 class Solution(object):
     def imageSmoother(self, M):
         """
         :type M: List[List[int]]
         :rtype: List[List[int]]
         """
         #padding
         m = len(M[0])
         N = [[0.5]+i+[0.5] for i in M]
         N = [[0.5]*(m+2)] + N + [[0.5]*(m+2)]
         
         #卷积
         for i in range(1,len(N)-1):
             for j in range(1,len(N[0])-1):
                 total = [N[i-1][j-1],N[i][j-1],N[i+1][j-1],N[i-1][j],N[i][j],N[i+1][j],N[i-1][j+1],N[i][j+1],N[i+1][j+1]]
                 sums,k = 0,0
                 for _ in total:
                     if _ != 0.5:
                         sums += _
                     else:
                         k += 1
                 M[i-1][j-1] = int(sums/(9-k))
         return M

\