美颜相机java

最新推荐文章于 2024-11-03 18:30:46 发布

张宇超666

最新推荐文章于 2024-11-03 18:30:46 发布

阅读量760

点赞数 9

文章标签：数码相机 java 开发语言

本文链接：https://blog.csdn.net/2301_79636742/article/details/141534933

版权

马赛克实现：

代码会遍历图像的像素，根据一定的块大小，将每个块的像素颜色平均化或设置为块中某个像素的颜色，从而实现马赛克效果。

    public void mosaic() {
        bufferZone();
        int x = s;// 代码会遍历图像的像素，根据一定的块大小，将每个块的像素颜色平均化或设置为块中某个像素的颜色，从而实现马赛克效果。
        int[][] data = image(fn);
        for (int i = 0; i < data.length; i += (15+1.6*x)) {
            for (int j = 0; j < data[i].length; j += (15+1.6*x)) {
                Color color = new Color(data[i][j]);
                bg.setColor(color);
                bg.fillRect(i / 2, j/ 2, 15, 15);// 在绘图缓冲区绘制一个矩形，模拟马赛克效果
            }
        }
        //把缓冲区显示在窗体；
        g.drawImage(bufferedImage,0,22,j1);
    }

灰度：

计算红绿蓝三个颜色通道的平均值作为灰度值，画笔调成该颜色再去绘制像素点

public void grey(){
        bufferZone();
        int[][] data = image(fn);
        for (int i = 0; i < data.length; i++){
            for (int j = 0; j < data[i].length; j++){
                Color color = new Color(data[i][j]);
                int red = color.getRed();
                int green = color.getGreen();
                int blue = color.getBlue();
                int sum = (red+green+blue)/3;// 计算红绿蓝三个颜色通道的平均值作为灰度值，用该颜色绘制像素点
                Color newColor = new Color(sum,sum,sum);
                bg.setColor(newColor);//画笔颜色
                bg.drawOval(i/2,j/2,1,1);//像素点
            }
        }
        //把缓冲区显示在窗体；
        g.drawImage(bufferedImage,0,22,j1);
    }

画原图

    public void oripic(){//通过bufferZone方法创建图像的缓冲区，然后遍历图像的每个像素点，使用fillOval画出每个像素
        bufferZone();// 准备绘图环境
        int[][] data = image(fn);//图片放在项目目录下
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
                //得到颜色值，画出每一个点
                Color c = new Color(data[i][j]);
                bg.setColor(c);//画笔颜色
                bg.fillOval(i / 2, j /2, 2, 2);//像素点
            }
        }

        //把缓冲区显示在窗体；
        g.drawImage(bufferedImage,0,22,j1);
    }

二值化：

设定一个阀值，超过的黑色，没过的白色，从而就黑白，即实现二值化

    public void binarization() {
        bufferZone();
        int x = s;// 定义二值化处理的阈值调整因子
        int[][] data = image(fn);
        int h = data.length;
        int w = data[0].length;
        for(int i = 0; i < h; i++){
            for(int j = 0; j < w; j++){
                int p = data[i][j];// 获取当前像素的颜色值
                Color color = new Color(p);// 根据颜色值创建颜色对象
                int blue = color.getBlue();
                if (blue >(70+2*x)){   // 根据蓝色分量与阈值的比较结果设置画笔颜色
                    bg.setColor(Color.BLACK);
                }else{
                    bg.setColor(Color.WHITE);
                }
                bg.drawOval(i/2,j/2,1,1);
            }
        }
        //把缓冲区显示在窗体；
        g.drawImage(bufferedImage,0,22,j1);
    }

放大：

遍历每个像素点，并在原位置周围绘制更大的矩形，实现放大效果。

    public void Todouble(){//遍历每个像素点，并在原位置周围绘制更大的矩形，实现放大效果。
        bufferZone();
        int x = s;
        int[][] data = image(fn);//图片放在项目目录下
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
                //得到颜色值，画出每一个点
                Color c = new Color(data[i][j]);
                bg.setColor(c);// 绘制一个矩形，实现图像的放大效果
                bg.fillRect(i*(x/2)/2, j *(x/2)/2, x, x);
            }
        }
        g.drawImage(bufferedImage, 0, 22, j1);

    }

缩小：

放大同理

    public void narrow(){
        bufferZone();
        int x = s;// 定义缩放因子
        int[][] data = image(fn);//图片放在项目目录下
        int w= data.length;
        int h=data[0].length;
        for (int i = 0; i < w; i+=2) {
            for (int j = 0; j < h; j+=2) {
                //得到颜色值，画出每一个点
                Color c = new Color(data[i][j]);
                bg.setColor(c);// 绘制一个矩形，宽度和高度为x，实现缩放效果
                bg.fillRect(i/(2*x) , j/(2*x), x, x);//通过每隔一定数量的像素点取一个像素，并在缩小后的图像上绘制相应的像素，实现缩小效果。
            }
        }
        g.drawImage(bufferedImage, 0, 22, j1);

    }

油画效果

在我看来就是把马赛克的划分像素再小一点，实现油彩笔拖动画画的效果

    public void oil(){
        bufferZone();
        int x = s;
        int[][] data = image(fn);
        for (int i =0; i < data.length-5; i +=5){// 遍历图像，跳过一定数量的像素点以模拟油画的笔触
            for (int j =0; j < data[i].length-5; j +=5) {
                Color color = new Color(data[i][j]);
                bg.setColor(color);
                Random ran=new Random();// 生成随机大小的椭圆，模拟油画的笔触效果
                int r1 = ran.nextInt(20)*x+5;
                int r2 = ran.nextInt(40)*x+5;
                bg.fillOval((i+x)/2, (j+x)/2,Math.max(r1,r2), Math.min(r1,r2));
            }
        }
        //把缓冲区显示在窗体；
        g.drawImage(bufferedImage,0,22,j1);
    }

哈哈镜：

根据鼠标点击的位置，计算每个像素点相对于点击点的距离和角度，然后根据这些值调整像素点的新位置

    public void funhouseMirror() {//根据鼠标点击的位置，计算每个像素点相对于点击点的距离和角度，然后根据这些值调整像素点的新位置
        bufferZone();
        int x = s;
        int[][] data = image(fn);
        int h=data.length;
        int w=data[0].length;
        int maxDist = (int) Math.sqrt((w/2 - a) * (w/2 - a) + (h/2 - b) * (h/2 - b));
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
                int deltaX = i - b;
                int deltaY = j - a;
                double distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
                int newX = (int) (i + deltaX * x * maxDist / distance*0.1);
                int newY = (int) (j + deltaY * x * maxDist / distance*0.1);

                if (newX >= 0 && newX < data.length && newY >= 0 && newY < data[i].length) {
                    Color color = new Color(data[newX][newY]);
                    bg.setColor(color);
                    bg.drawOval(i/2, j/2, 1, 1);
                }
            }
        }
        // 把缓冲区显示在窗体；
        g.drawImage(bufferedImage, 0, 22, j1);
    }

这里解释一下：

计算位移量: deltaX * x * maxDist / distance * 0.1 和 deltaY * x * maxDist / distance * 0.1 计算了像素应移动的距离。

比例因子: (maxDist / distance) 用于调整移动量，使得离点击点更远的像素点移动更多。这样就实现了拉伸效果。

远离点击点的像素：对于离点击点更远的像素，distance 较大，但 (maxDist / distance) 比例较小；然而，由于 deltaX 和 deltaY 的值较大，这些像素点的移动幅度仍然会很大。
靠近点击点的像素：对于离点击点更近的像素，distance 较小，而 (maxDist / distance) 比例较大，但由于 deltaX 和 deltaY 的值较小，这些像素点的移动幅度较小。
放大或缩小: 由于公式中乘以了 x 和 0.1，拉伸或压缩效果可以被调节。

当 x 增大时，拉伸效果会变得更显著。
当 x 减小时（接近于0），拉伸效果会减少，直到完全没有变形

加密

就是输入的askII添加到蓝色阈的最后两位

最后附上源码

package meiyan0811complete;
import javax.imageio.ImageIO;//用于读取和写入图片
import javax.swing.*;//构建图形用户界面
import java.awt.*;//处理组件和画图
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;//处理图像缓冲区
import java.io.File;
import java.io.IOException;
import java.util.Random;
import java.util.Scanner;

public class DrawMouse implements ActionListener,MouseListener {
    public Graphics g;// 绘制图形
    private Graphics bg;//背景绘制

    private BufferedImage bufferedImage;
    public String str;//存储按钮点击事件的字符串

    public JPanel j1=null;
    public int s=1 ;//用于存储滑动条的值，默认为1

    public int a,b;// 鼠标点击位置的x,y坐标
    public String fn = "D:\\桌面\\11.jpg";

    public void mouseClicked(MouseEvent e){
        int x =a= e.getX();
        int y =b= e.getY();
    }
    public void mousePressed(MouseEvent e){}
    public void mouseReleased(MouseEvent e){}
    public void mouseEntered(MouseEvent e){}
    public void mouseExited(MouseEvent e){}






    public void actionPerformed(ActionEvent e) {//处理按钮点击
        String btnStr = e.getActionCommand();//获取输入的命令
        str = btnStr;
        System.out.println("用户点击了" + btnStr+"按钮......");
        System.out.println("稍等一会，图片效果马上呈现");
        // 使用SwingWorker来执行异步图像处理，是Java Swing库中的一个类
        // 它提供了一种在后台线程中执行长时间运行的任务并更新Swing用户界面的方法。
        SwingWorker<Void, Void> worker = new SwingWorker<Void, Void>() {
            protected Void doInBackground() {
                // 根据按钮选择的效果处理图像
                //根据字符串绘制相关图片
                switch (btnStr) {
                    case "原图":
                        oripic();
                        break;
                    case "灰度"://取rgb平均值，则画成灰度图
                        grey();
                        break;
                    case "二值化":
                        binarization();
                        break;
                    case "马赛克":
                        mosaic();
                        break;
                    case"放大":
                        Todouble();
                        break;
                    case"缩小":
                        narrow();
                        break;
                    case"油画":
                        oil();
                        break;
                    case"哈哈镜":
                        funhouseMirror();
                        break;
                    case "旋转":
                        spin();
                        break;
                    case "加密":
                        encrypt();
                        break;
                }
                return null;
            }
            protected void done() {
                g.drawImage(bufferedImage, 0, 22, j1);// 将处理后的图像绘制到JPanel上
            }
        };

        worker.execute();//启动一个后台任务，该任务在 doInBackground() 中执行图像处理，完成后在 done() 中更新UI
    }

    //程序的执行过程：代码 > jvm > os > 总线 > 显示器
    //创建缓冲区 把所有的像素点显示在缓存去上
    public void bufferZone() {
        int[][] data = image(fn);// 将图片文件转换为int型的二维数组
        bufferedImage = new BufferedImage( data.length, data[0].length,BufferedImage.TYPE_INT_RGB);
        bg = bufferedImage.getGraphics();
        bg.setColor(Color.WHITE);
        bg.fillRect(0,0,bufferedImage.getWidth(),bufferedImage.getHeight());
    }



    public void oripic(){//通过bufferZone方法创建图像的缓冲区，然后遍历图像的每个像素点，使用fillOval画出每个像素
        bufferZone();// 准备绘图环境
        int[][] data = image(fn);//图片放在项目目录下
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
                //得到颜色值，画出每一个点
                Color c = new Color(data[i][j]);
                bg.setColor(c);//画笔颜色
                bg.fillOval(i / 2, j /2, 2, 2);//像素点
            }
        }

        //把缓冲区显示在窗体；
        g.drawImage(bufferedImage,0,22,j1);
    }
    public void grey(){
        bufferZone();
        int[][] data = image(fn);
        for (int i = 0; i < data.length; i++){
            for (int j = 0; j < data[i].length; j++){
                Color color = new Color(data[i][j]);
                int red = color.getRed();
                int green = color.getGreen();
                int blue = color.getBlue();
                int sum = (red+green+blue)/3;// 计算红绿蓝三个颜色通道的平均值作为灰度值，用该颜色绘制像素点
                Color newColor = new Color(sum,sum,sum);
                bg.setColor(newColor);//画笔颜色
                bg.drawOval(i/2,j/2,1,1);//像素点
            }
        }
        //把缓冲区显示在窗体；
        g.drawImage(bufferedImage,0,22,j1);
    }

    public void mosaic() {
        bufferZone();
        int x = s;// 代码会遍历图像的像素，根据一定的块大小，将每个块的像素颜色平均化或设置为块中某个像素的颜色，从而实现马赛克效果。
        int[][] data = image(fn);
        for (int i = 0; i < data.length; i += (15+1.6*x)) {
            for (int j = 0; j < data[i].length; j += (15+1.6*x)) {
                Color color = new Color(data[i][j]);
                bg.setColor(color);
                bg.fillRect(i / 2, j/ 2, 15, 15);// 在绘图缓冲区绘制一个矩形，模拟马赛克效果
            }
        }
        //把缓冲区显示在窗体；
        g.drawImage(bufferedImage,0,22,j1);
    }

    public void binarization() {
        bufferZone();
        int x = s;// 定义二值化处理的阈值调整因子
        int[][] data = image(fn);
        int h = data.length;
        int w = data[0].length;
        for(int i = 0; i < h; i++){
            for(int j = 0; j < w; j++){
                int p = data[i][j];// 获取当前像素的颜色值
                Color color = new Color(p);// 根据颜色值创建颜色对象
                int blue = color.getBlue();
                if (blue >(70+2*x)){   // 根据蓝色分量与阈值的比较结果设置画笔颜色
                    bg.setColor(Color.BLACK);
                }else{
                    bg.setColor(Color.WHITE);
                }
                bg.drawOval(i/2,j/2,1,1);
            }
        }
        //把缓冲区显示在窗体；
        g.drawImage(bufferedImage,0,22,j1);
    }

    public void narrow(){
        bufferZone();
        int x = s;// 定义缩放因子
        int[][] data = image(fn);//图片放在项目目录下
        int w= data.length;
        int h=data[0].length;
        for (int i = 0; i < w; i+=2) {
            for (int j = 0; j < h; j+=2) {
                //得到颜色值，画出每一个点
                Color c = new Color(data[i][j]);
                bg.setColor(c);// 绘制一个矩形，宽度和高度为x，实现缩放效果
                bg.fillRect(i/(2*x) , j/(2*x), x, x);//通过每隔一定数量的像素点取一个像素，并在缩小后的图像上绘制相应的像素，实现缩小效果。
            }
        }
        g.drawImage(bufferedImage, 0, 22, j1);

    }
    public void Todouble(){//遍历每个像素点，并在原位置周围绘制更大的矩形，实现放大效果。
        bufferZone();
        int x = s;
        int[][] data = image(fn);//图片放在项目目录下
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
                //得到颜色值，画出每一个点
                Color c = new Color(data[i][j]);
                bg.setColor(c);// 绘制一个矩形，实现图像的放大效果
                bg.fillRect(i*(x/2)/2, j *(x/2)/2, x, x);
            }
        }
        g.drawImage(bufferedImage, 0, 22, j1);

    }

    public void oil(){
        bufferZone();
        int x = s;
        int[][] data = image(fn);
        for (int i =0; i < data.length-5; i +=5){// 遍历图像，跳过一定数量的像素点以模拟油画的笔触
            for (int j =0; j < data[i].length-5; j +=5) {
                Color color = new Color(data[i][j]);
                bg.setColor(color);
                Random ran=new Random();// 生成随机大小的椭圆，模拟油画的笔触效果
                int r1 = ran.nextInt(20)*x+5;
                int r2 = ran.nextInt(40)*x+5;
                bg.fillOval((i+x)/2, (j+x)/2,Math.max(r1,r2), Math.min(r1,r2));
            }
        }
        //把缓冲区显示在窗体；
        g.drawImage(bufferedImage,0,22,j1);
    }


    public void funhouseMirror() {//根据鼠标点击的位置，计算每个像素点相对于点击点的距离和角度，然后根据这些值调整像素点的新位置
        bufferZone();
        int x = s;
        int[][] data = image(fn);
        int h=data.length;
        int w=data[0].length;
        int maxDist = (int) Math.sqrt((w/2 - a) * (w/2 - a) + (h/2 - b) * (h/2 - b));
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
                int deltaX = i - b;
                int deltaY = j - a;
                double distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
                int newX = (int) (i + deltaX * x * maxDist / distance*0.1);
                int newY = (int) (j + deltaY * x * maxDist / distance*0.1);

                if (newX >= 0 && newX < data.length && newY >= 0 && newY < data[i].length) {
                    Color color = new Color(data[newX][newY]);
                    bg.setColor(color);
                    bg.drawOval(i/2, j/2, 1, 1);
                }
            }
        }
        // 把缓冲区显示在窗体；
        g.drawImage(bufferedImage, 0, 22, j1);
    }

    //对于每个字符的信息，程序会获取其ASCII码值，并且将这个值的最低两位与蓝色分量的最低两位进行位运算，从而隐藏信息。
    //遍历每个像素点，将输入的文本信息的ASCII码值隐藏在像素点的蓝色通道的最低2位，然后使用修改后的颜色值绘制像素点。

    public void encrypt(){
        bufferZone();
        int[][] data = image(fn);
        System.out.println("请输入所要加入图像里的信息:");
        Scanner scanner = new Scanner(System.in);
        String messageToEncrypt = scanner.nextLine();
        scanner.close();
        int messageIndex = 0;

        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
                if (messageIndex < messageToEncrypt.length()) {
                    Color color = new Color(data[i][j]);
                    int red = color.getRed();
                    int green = color.getGreen();
                    int blue = color.getBlue();

                    char charToHide = messageToEncrypt.charAt(messageIndex);
                    int asciiValue = (int) charToHide;

                    // 将ASCII码值存储到蓝色通道的最低2位
                    blue = (blue & 0xFC) | ((asciiValue >> 6) & 0x03);
                    Color newColor = new Color(red, green, blue);

                    bg.setColor(newColor);
                    bg.drawOval(i / 2, j / 2, 1, 1);

                    messageIndex++;
                } else {
                    // 如果已经加密完整个信息，则将原图像像素写入缓冲区
                    Color color = new Color(data[i][j]);
                    bg.setColor(color);
                    bg.drawOval(i / 2, j / 2, 1, 1);
                }
            }
        }

        // 把缓冲区显示在窗体；
        g.drawImage(bufferedImage, 0, 22, j1);
        try {
            File outputImageFile = new File("encrypted_image.jpg"); // 新文件的路径
            ImageIO.write(bufferedImage, "jpg", outputImageFile);
            System.out.println("加密后的图像已保存到文件 'encrypted_image.jpg'");
        } catch (IOException e) {
            System.out.println("保存图像文件时出现错误: " + e.getMessage());
        }
    }

    public void spin(){
        bufferZone();
        int x = s;
        int[][] data = image(fn);

    }



    //将一张图片转化一个int型的二维数组
    private int[][] image(String imageName) {
        File file = new File(fn);
        BufferedImage bi = null;
        try {
            bi = ImageIO.read(file); //从文件到图片对象
        } catch (Exception e) {//catch块用于捕获并处理try块中抛出的任何异常。这里的Exception e表示捕获所有类型的异常
            e.printStackTrace();
        }
        int w = bi.getWidth(); //图片的宽
        int h = bi.getHeight(); //图片的高
        int[][] imIndex = new int[w][h];//存像素值的二维数组
        for (int i = 0; i < w; i++) {
            for (int j = 0; j < h; j++) {
                imIndex[i][j] = bi.getRGB(i, j); //i,j 位置的 Color 值，每个像素点的 color 存入数组
            }
        }
        return imIndex;
    }
}

package meiyan0811complete;

import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;

public class ImageBoard  extends  JFrame {
    //private  DrawMouse dl=null;
    String fName;
    DrawMouse mouse = new DrawMouse();

    public void initUI() {


        //窗体的创建
        this.setTitle("PC版美颜相机--by 张宇超");
        this.setSize(1000, 600);
        this.getContentPane().setBackground(Color.WHITE);
        this.setDefaultCloseOperation(3);
        this.setLocationRelativeTo(null);
        this.setLayout(new BorderLayout());

        //按钮面板  对象JPanel  默认是流式布局
        JPanel eastPanel = new JPanel();
        eastPanel.setBackground(new Color(220,226,248));
        eastPanel.setPreferredSize(new Dimension(200,0));
        this.add(eastPanel,BorderLayout.EAST);

        //图画面板
        JPanel drawPanel = new JPanel();
        drawPanel.setBackground(Color.WHITE);
        drawPanel.setPreferredSize(new Dimension(800,500));
        this.add(drawPanel,BorderLayout.CENTER);
        mouse.j1=drawPanel;
        drawPanel.addMouseListener(mouse);

        this.setVisible(true);
        Graphics g=drawPanel.getGraphics();
        mouse.g = g;


        String[] strs={"原图","二值化","灰度","马赛克","放大","缩小","油画","哈哈镜","旋转","加密"};
        Color primaryColor = new Color(137, 190, 178);
        Color textColor = Color.WHITE;
        // 应用颜色方案到按钮
        Font buttonFont = new Font("宋体", Font.PLAIN, 16); // 设置按钮字体和字号
        for(int i=0;i< strs.length;i++) {
            JButton buDraw = new JButton(strs[i]); // 对于字符串数组strs中的每一个字符串，创建一个新的JButton对象。
            buDraw.setPreferredSize(new Dimension(80,30));//按钮大小
            buDraw.setBackground(primaryColor);//背景颜色
            buDraw.setForeground(textColor);//按钮前景颜色
            buDraw.setFont(buttonFont);//应用字体
            buDraw.setBorder(BorderFactory.createEmptyBorder(5, 15, 5, 15));
            //创建一个空白边框，为按钮的内容留出一些空间，使其看起来更加整洁和美观。
            eastPanel.add(buDraw);//按钮添加到面板里
            buDraw.addActionListener(mouse);//动作监听器
        }
        JLabel j1 = new JLabel("大小/程度选择：");//显示文本的label
        j1.setFont(new Font("黑体",1,15));
        eastPanel.add(j1);

        JMenuBar jmb = new JMenuBar();//菜单栏
        JMenu jm = new JMenu();//菜单栏里面的菜单项
        jm.setText("文件");
        jmb.add(jm);
        this.setJMenuBar(jmb);
        JMenuItem open = new JMenuItem();//菜单项
        open.setText("Open");
        jm.add(open);
        //按钮键->按钮功能(动作监听器)
        open.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                if(e != null){
                    JFileChooser jfc =new JFileChooser();
                    jfc.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);//创建文件选择器
                    jfc.showDialog(new Label(),"选中");
                    File file = jfc.getSelectedFile();
                    fName = file.getPath();
                    mouse.fn = fName;
                }
            }
        });

        //拉杆，滑动条可能用于控制图像处理的强度、大小或其他可调节的参数
        JSlider js1 = new JSlider(1,10);// 创建一个滑动条，范围从1到10
        js1.setMajorTickSpacing(1);// 设置主刻度之间的间距为1。
        js1.setMinorTickSpacing(1);// 设置次刻度之间的间距为1。
        js1.setPreferredSize(new Dimension(200,80));
        js1.setFont (new Font ("黑体",1,15));
        js1.setPaintLabels(true);
        js1.setPaintTicks(true);
        js1.setSnapToTicks(true);
        js1.setOpaque(false);
        js1.setValue(1);
        eastPanel.add(js1);
        js1.addChangeListener(new ChangeListener() {
            public void stateChanged(ChangeEvent e) {
                g.setColor(Color.WHITE);
                g.fillRect(0,100,1000,1000);
                if(e != null){
                    int x =js1.getValue();
                    mouse.s = x;
                }
            }
        });
    }

    public void paint(Graphics g) {
        super.paint(g);
        if (mouse.fn != null){
            switch (mouse.str){
                case "原图":
                    mouse.oripic();
                    break;
                case "灰度":
                    mouse.grey();
                    break;
                case "二值化":
                    mouse.binarization();
                    break;
                case "马赛克":
                    mouse.mosaic();
                    break;
                case "放大":
                    mouse.Todouble();
                    break;
                case "缩小":
                    mouse.narrow();
                    break;
                case "油画":
                    mouse.oil();
                    break;
                case"哈哈镜":
                    mouse.funhouseMirror();
                    break;
                case"旋转":
                    mouse.spin();
                    break;
                case"加密":
                    mouse.encrypt();
                    break;
                default:
                    break;
            }
        }
    }

    public static void main(String[] args) {
        new ImageBoard().initUI();
    }

}
注释也很详细