Given a 2D integer matrix M representing the gray scale of an image, you need to design a smoother to make the gray scale of each cell becomes the average gray scale (rounding down) of all the 8 surrounding cells and itself. If a cell has less than 8 surrounding cells, then use as many as you can.
Example 1:
Input:
[[1,1,1],
[1,0,1],
[1,1,1]]Output:
[[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]Explanation:
For the point (0,0), (0,2), (2,0), (2,2): floor(3/4) = floor(0.75) = 0
For the point (0,1), (1,0), (1,2), (2,1): floor(5/6) = floor(0.83333333) = 0
For the point (1,1): floor(8/9) = floor(0.88888889) = 0Note:
The value in the given matrix is in the range of [0, 255].
The length and width of the given matrix are in the range of [1, 150].
How to Smooth Image in C++?
The following C++ code implements O(N) algorithm (where N is the number of pixels in the image) that iterates each pixel. We can’t modify the existing image, rather, it has to be done on a separate copy of image.
We can deep copy the std::vector, or just assign new pixel to it.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | class Solution { public: vector<vector<int>> imageSmoother(vector<vector<int>>& M) { int row = M.size(); if (row == 0) return M; int width = M[0].size(); if (width == 0) return M; vector<vector<int>> N(row, vector<int>(width)); // or N = M deep copy of vector for (int i = 0; i < row; ++ i) { for (int j = 0; j < width; ++ j) { int sum = 0, c = 0; for (int k = max(0, i - 1); k <= min(i + 1, row - 1); k ++) { for (int u = max(0, j - 1); u <= min(j + 1, width - 1); u ++) { sum += M[k][u]; c ++; } } N[i][j] = sum / c; } } return N; } }; |
class Solution {
public:
vector<vector<int>> imageSmoother(vector<vector<int>>& M) {
int row = M.size();
if (row == 0) return M;
int width = M[0].size();
if (width == 0) return M;
vector<vector<int>> N(row, vector<int>(width)); // or N = M deep copy of vector
for (int i = 0; i < row; ++ i) {
for (int j = 0; j < width; ++ j) {
int sum = 0, c = 0;
for (int k = max(0, i - 1); k <= min(i + 1, row - 1); k ++) {
for (int u = max(0, j - 1); u <= min(j + 1, width - 1); u ++) {
sum += M[k][u];
c ++;
}
}
N[i][j] = sum / c;
}
}
return N;
}
};We can check if the neighbour index of pixels are valid. Alternatively, we can use min/max to make sure the indices are always valid. We don’t need to use floor function as the integer division is floor anyway.
How to Smooth Image in Java?
The same image smooth algorithm can be implemented in Java as follows.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | class Solution { public int[][] imageSmoother(int[][] M) { int row = M.length; if (row == 0) return M; int width = M[0].length; if (width == 0) return M; int[][] N = new int[row][width]; for (int i = 0; i < row; ++ i) { for (int j = 0; j < width; ++ j) { int sum = 0, c = 0; for (int k = Math.max(0, i - 1); k <= Math.min(i + 1, row - 1); k ++) { for (int u = Math.max(0, j - 1); u <= Math.min(j + 1, width - 1); u ++) { sum += M[k][u]; c ++; } } N[i][j] = sum / c; } } return N; } } |
class Solution {
public int[][] imageSmoother(int[][] M) {
int row = M.length;
if (row == 0) return M;
int width = M[0].length;
if (width == 0) return M;
int[][] N = new int[row][width];
for (int i = 0; i < row; ++ i) {
for (int j = 0; j < width; ++ j) {
int sum = 0, c = 0;
for (int k = Math.max(0, i - 1); k <= Math.min(i + 1, row - 1); k ++) {
for (int u = Math.max(0, j - 1); u <= Math.min(j + 1, width - 1); u ++) {
sum += M[k][u];
c ++;
}
}
N[i][j] = sum / c;
}
}
return N;
}
}–EOF (The Ultimate Computing & Technology Blog) —
loading...
Last Post: How to Sum the Root To Leaf in Binary Numbers in a Binary Tree using Breadth First Search?
Next Post: The Alien Dictionary Verification Algorithm