一个利用卷积运算处理图像的小工具

卷积是图像处理和深度学习的重要工具之一。说白了这里用的卷积的其实是一种矩阵的运算方式，如下图所示，对于两个矩阵做卷积运算，实际上就是对应位置的数字相乘之后加和。

在图像处理中，我们一般会将图片转为矩阵形式作为卷积运算的一项，和另取的一个长和宽较小的矩阵（成为卷积核）进行运算。由于两个矩阵的长和宽不相等，会取大矩阵中和小矩阵长宽相等的子矩阵运算（如图中依次红绿蓝橙色框），这样形成的结果依然为一个矩阵，也就是矩阵卷积运算得到的结果。

在卷积环节中，卷积核的选取决定了卷积的功能，举个特殊的例子，如果卷积核的选取为[ [0, 0，0], [0, 1, 0], [0, 0, 0] ]，在与图片矩阵运算之后什么也不会发生，而如果选取[ [ -1, 0, 1], [0, 1, 0] , [1, 0, -1] ]就会有较好的提取边框作用。因此，卷积核的选取决定了卷积运算的效果，需要根据需求灵活选择。

想要实现卷积前需要一点点的准备工作，首先我们先创建一个能显示图像的小程序。

package com.image;

import javax.swing.*;
import java.awt.*;
import java.awt.image.BufferedImage;

public class ImageProcessorUI {
    private Listener listener;
    private Graphics graphics;
    private JFrame jFrame;
    private final ImageProcessor imageProcessor;
    JTextField imagePath;
    int[][] image_matrix;

    public ImageProcessorUI() {
        imageProcessor = ImageProcessor.getProcessor();
    }

    public void init() {
        jFrame = new JFrame();
        jFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        jFrame.setSize(850, 650);
        jFrame.setBackground(new Color(218, 209, 209));
        BorderLayout borderLayout = new BorderLayout();
        jFrame.setLayout(borderLayout);
        initPanel();
        jFrame.setVisible(true);
        jFrame.addMouseListener(listener);
        this.graphics = jFrame.getGraphics();
    }

    private void initPanel() {
        JPanel right_panel = new JPanel();
        right_panel.setPreferredSize(new Dimension(200, 600));
        right_panel.setBackground(new Color(0x6993CB));

        imagePath = new JTextField();
        imagePath.setPreferredSize(new Dimension(180, 50));
        imagePath.addActionListener(listener);
        imagePath.setText("D:\\test.png");
        right_panel.add(imagePath);

        String[] button_list = {"加入图片",  "滤镜"};
        for (String s : button_list) {
            JButton jButtons = new JButton(s);
            jButtons.setSize(100, 50);
            jButtons.setBackground(new Color(35, 191, 218, 100));
            jButtons.addActionListener(listener);
            jButtons.addMouseListener(listener);
            right_panel.add(jButtons);
        }
        jFrame.add(right_panel, BorderLayout.EAST);
    }

    public void setListener(Listener listener) {
        this.listener = listener;
    }

    public static void main(String[] args) {
        ImageProcessorUI imageProcessorUI = new ImageProcessorUI();
        Listener listener = new Listener(imageProcessorUI);
        imageProcessorUI.imageProcessor.imageProcessorUI = imageProcessorUI;
        imageProcessorUI.setListener(listener);
        imageProcessorUI.init();

    }

    public void printImage() {
        BufferedImage image = new BufferedImage(600, 600, BufferedImage.TYPE_INT_ARGB);
        Graphics image_graphics = image.getGraphics();
        for (int i = 0; i < 600; i++) {
            for (int j = 0; j < 600; j++) {
                image_graphics.setColor(new Color(image_matrix[i][j]));
                image_graphics.drawRect(i, j, 1, 1);
            }
        }
        graphics.drawImage(image, 25, 35, null);
    }


}

```java
package com.image;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.IOException;


public class Listener extends MouseAdapter implements ActionListener {
    ImageProcessor imageProcessor;
    ImageProcessorUI imageProcessorUI;
    boolean reMask = false;

    {
        imageProcessor = ImageProcessor.getProcessor();
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        String command = e.getActionCommand();
        if (command.equals("加入图片")) {
            try {
                imageProcessor.put_into_matrix(imageProcessor.insert_image());
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            imageProcessorUI.printImage();
        } else if (command.equals("滤镜")) {
//            int[][] kernel = {{-1, 0, 1}, {0, 1, 0}, {1, 0, -1}};
            int[][] kernel = {{-1, -1, -1, -1, 0}, {-1, -1, -1, 0, 1}, {-1, -1, 0, 1, 1}, {-1, 0, 1, 1, 1}, {0, 1, 1, 1, 1}};
            imageProcessor.convolution(kernel);
            imageProcessorUI.printImage();
        }
    }

    public Listener(ImageProcessorUI imageProcessorUI) {
        this.imageProcessorUI = imageProcessorUI;
    }

}

package com.image;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class ImageProcessor {

    static final ImageProcessor imageProcessor = new ImageProcessor();
    ImageProcessorUI imageProcessorUI;

    public BufferedImage insert_image() throws IOException {
        File file = new File(imageProcessorUI.imagePath.getText());
        BufferedImage image;
        image = ImageIO.read(file);
        return image;
    }

    public void put_into_matrix(BufferedImage image) {
        int[][] image_matrix = new int[600][600];
        for (int i = 0; i < 600; i++) {
            for (int j = 0; j < 600; j++) {
                image_matrix[i][j] = image.getRGB((int) ((double) image.getWidth() / 600 * i), (int) ((double) image.getHeight() / 600 * j));
            }
        }
        imageProcessorUI.image_matrix = image_matrix;
    }


    private ImageProcessor() {
    }

    public static ImageProcessor getProcessor() {
        return imageProcessor;
    }



    public void convolution(int[][] kernel) {
        int[][] matrix = new int[600][600];
        for (int i = 0; i < 600; i++) {
            for (int j = 0; j < 600; j++) {
                matrix[i][j] = imageProcessorUI.image_matrix[i][j];
            }
        }
        int h = kernel.length;
        int w = kernel[0].length;
        for (int i = 0; i < 600 - (h - 1); i++) {
            for (int j = 0; j < 600 - (w - 1); j++) {
                int r = 0, g = 0, b = 0;
                for (int k = 0; k < kernel.length; k++) {
                    for (int l = 0; l < kernel[0].length; l++) {
                        r += kernel[k][l] * (imageProcessorUI.image_matrix[i + k][j + l] >> 16 & 0xFF);
                        g += kernel[k][l] * (imageProcessorUI.image_matrix[i + k][j + l] >> 8 & 0xFF);
                        b += kernel[k][l] * (imageProcessorUI.image_matrix[i + k][j + l] & 0xFF);
                    }
                }
                if (r > 255) r = 255;
                if (g > 255) g = 255;
                if (b > 255) b = 255;
                if (r < 0) r = 0;
                if (g < 0) g = 0;
                if (b < 0) b = 0;
                matrix[i + (h - 1) / 2][j + (w - 1) / 2] = 0xFF000000 | (r << 16) | (g << 8) | b;
            }
        }
        for (int i = 0; i < 600; i++) {
            for (int j = 0; j < 600; j++) {
                imageProcessorUI.image_matrix[i][j] = matrix[i][j];
            }
        }
    }

}

以下是该代码实现的效果图，在输入框内可以输入目标图片地址，后点击“加入图片”载入到画面上

后点击滤镜就可以观察到卷积之后的结果了