Java美颜相机（2）图像处理各种滤镜

利用RGB特性，给图片加上各种滤镜（原图，灰度，二值化，冷色，暖色，怀旧，灵魂出窍（照片底色），铁砂网，美白，放大2倍，乐高，ARGB，画布刷新）

原图

灰度

二值化

随机马赛克

灵魂出窍（照片底色）

冷色

暖色

怀旧

铁砂网

美白（和原图对比看，效果不明显）

乐高

转化为ARGB格式，透明度变成原来的一半

放大两倍（左上角是原图，为了方便对比放在最上面）

代码实现(太多就不分开写了，具体有注释)

public class Drawlistener implements MouseListener, ActionListener {

    Graphics gr;
    DrawUI ui;
    String graphics_type;
    DrawUI.DrawPanel drawPanel;

    BufferedImage image_display;
    int[][]imageArray_display;

    //初始化函数
    Drawlistener(Graphics gr){ this.gr =gr;}

    public void setGraphics(Graphics graphics){
        this.gr = graphics;
    }
    //  设置drawPanel 方便刷新
    public void setGrawUI(DrawUI.DrawPanel drawPanel){
        this.drawPanel = drawPanel;
    }
    //  刷新画板，即调用paint方法
    public void refrash(){
        this.drawPanel.paint(gr);
    }

    /**
     * @param e 按钮事件
     * 按钮事件
     */
    @Override
    public void actionPerformed(ActionEvent e) {

        String btnstr = e.getActionCommand ();

        if (btnstr.equals("原图")){
            graphics_type ="原图";
            paint_original(gr);

        }else if(btnstr.equals("灰度")){
            graphics_type ="灰度";
            // 遍历二维数组来绘制图片
            draw_gray_Image(imageArray_display,gr);

        }else if(btnstr.equals("二值化")){
            graphics_type ="二值化";
            draw_Image_binarization(imageArray_display,gr);
        }else if(btnstr.equals("随机马赛克")){
            graphics_type ="随机马赛克";
            draw_Mosaic(gr);
        }else if (btnstr.equals("冷色")){
            graphics_type ="冷色";
            draw_cold(gr);
        }else if (btnstr.equals("暖色")){
            graphics_type ="暖色";
            draw_warm(gr);
        }else if(btnstr.equals("灵魂出窍")){
            graphics_type ="灵魂出窍";
            draw_photo_negative(gr);
        }else if(btnstr.equals("怀旧")){
            graphics_type ="怀旧";
            draw_oldimage(gr);
        }else if(btnstr.equals("放大2倍")){
            graphics_type ="放大2倍";
            draw_bigger_2(gr);
        }else if(btnstr.equals("美白")){
            graphics_type ="美白";
            draw_Whitening(gr);
        }else if (btnstr.equals("铁砂网")){
            graphics_type ="铁砂网";
            draw_oil_painting(gr);
        }else if (btnstr.equals("乐高")){
            graphics_type ="乐高";
            draw_LEGO(gr);
        }else if (btnstr.equals("刷新")){
            graphics_type ="刷新";
            refrash();
        }else if (btnstr.equals("ARGB")){
            graphics_type ="ARGB";
            draw_ARGB(gr);
            pixelToRGB();
        }

    }



    /**
     * 整数转三原色值
     */
    public void pixelToRGB(){
        // 将一个像素值 转为 三原色值
        int num = 8421504;
        int red = (num >> 16) & 0xFF;
        System.out.println ("红"+red);
        int green = (num >> 8) & 0xFF;
        System.out.println ("绿"+green);
        int blue = (num >> 0) & 0xFF;
        System.out.println ("蓝"+blue);
        // 将 三原色值 合为 一个像素值
    }


    /**
     * 转化为ARGB模式： ARGB默认是透明度为255（就是不透明的）RGB
     *
     */

    public void draw_ARGB(Graphics g){
        for(int i = 0; i < imageArray_display.length; i++){
            for(int j = 0; j < imageArray_display[i].length; j++){
                // 取出像素值
                int i1 = imageArray_display[i][j];
                // 拆分为 三原色值
                int red = (i1 >> 16) & 0xFF;
                int green = (i1 >> 8) & 0xFF;
                int blue = (i1 >> 0) & 0xFF;
                int transparency =(i1 >> 24) & 0xFF;



                Color color = new Color (red,green,blue,transparency/2);
                g.setColor(color);
                g.fillRect ( i, j, 1, 1);
            }
        }
    }


    /**
     * 乐高EGO模式看起来像一个一个乐高拼起来的照片，具体可以看乐高的壁画
     * 每间隔2个像素，画一个直径为1的正方形
     */
    public void draw_LEGO(Graphics g){
        for(int i = 0; i < imageArray_display.length; i++){
            for(int j = 0; j < imageArray_display[i].length; j++){
                // 取出像素值
                int i1 = imageArray_display[i][j];
                // 拆分为 三原色值
                int red = (i1 >> 16) & 0xFF;
                int green = (i1 >> 8) & 0xFF;
                int blue = (i1 >> 0) & 0xFF;
                Color color = new Color (red,green,blue);
                if ((i&3) ==0 || (j&3) ==0){
                    color = Color.BLACK;
                }
                g.setColor(color);
                g.fillRect ( i+500, j, 1, 1);
            }
        }
    }


    /**
     * 铁砂网
     * 每间隔2个像素，画一个直径为1的圆
     */
    public void draw_oil_painting(Graphics g){
        for(int i = 0; i < imageArray_display.length; i+=2){
            for(int j = 0; j < imageArray_display[i].length; j+=2){
                // 取出像素值
                int i1 = imageArray_display[i][j];
                // 拆分为 三原色值
                int red = (i1 >> 16) & 0xFF;
                int green = (i1 >> 8) & 0xFF;
                int blue = (i1 >> 0) & 0xFF;
                Color color = new Color (red,green,blue);
                g.setColor(color);
                g.fillOval ( i+500, j, 1, 1);
            }
        }
    }
    /**
     * 美白 把每个像素的RGB值 -10
     */
    public void draw_Whitening(Graphics g){
        for(int i = 0; i < imageArray_display.length; i++){

            for(int j = 0; j < imageArray_display[i].length; j++){
                // 取出像素值
                int i1 = imageArray_display[i][j];
                // 拆分为 三原色值
                int red = (i1 >> 16) & 0xFF;
                int green = (i1 >> 8) & 0xFF;
                int blue = (i1 >> 0) & 0xFF;

                //把每个像素的RGB值 +10
                if (green+10 <= 255 && red+10 <= 255 && blue+10 <= 255 ){
                    red =red+10;
                    green =green+10;
                    blue =blue+10;
                }

                Color color = new Color (red,green,blue);
                g.setColor(color);
                g.fillRect ( i, j, 1, 1);
            }
        }
    }




    /**
     *把图像放大2倍
     * 原来 —— 一个小像素 —— 边长为1的正方形
     * 现在 —— 一个大像素 —— 边长为2的正方形
     */
    public void draw_bigger_2(Graphics g){
        for(int i = 0; i < imageArray_display.length; i++){

            for(int j = 0; j < imageArray_display[i].length; j++){
                // 取出像素值
                int i1 = imageArray_display[i][j];
                // 拆分为 三原色值
                int red = (i1 >> 16) & 0xFF;
                int green = (i1 >> 8) & 0xFF;
                int blue = (i1 >> 0) & 0xFF;

                Color color = new Color (red,green,blue);
                g.setColor(color);
                g.fillRect ( i*2, j*2, 2, 2);
            }
        }
    }


    /**
     * 暖色  红+ 其他-
     * 冷色  蓝+ 其他-
     * 怀旧  绿+红+ 蓝-
     * 红+绿 =黄
     * 调出各种风格 只要搞懂GRB怎么调色就好
     */
    public void draw_oldimage(Graphics g){
        for(int i = 0; i < imageArray_display.length; i++){
            for(int j = 0; j < imageArray_display[i].length; j++){
                // 取出像素值
                int i1 = imageArray_display[i][j];
                // 拆分为 三原色值
                int red = (i1 >> 16) & 0xFF;
                int green = (i1 >> 8) & 0xFF;
                int blue = (i1 >> 0) & 0xFF;
                if (green+25 <= 255 && red+25 <= 255 &&blue-25>=0 ){
                    green =green+25;
                    red =red+25;
                    blue =blue-25;
                }
                // 操作三原色值 实现滤镜
                // 冷：blue++
                Color color = new Color (red,green,blue);
                g.setColor(color);
                g.fillRect ( i, j, 1, 1);
            }
        }
    }



    /**
     * 暖色  红+ 其他-
     * 冷色  蓝+ 其他-
     * 黄昏  黄+ 其他-
     * 这个是冷色
     */
    public void draw_cold(Graphics g){
        for(int i = 0; i < imageArray_display.length; i++){
            for(int j = 0; j < imageArray_display[i].length; j++){
                // 取出像素值
                int i1 = imageArray_display[i][j];
                // 拆分为 三原色值
                int red = (i1 >> 16) & 0xFF;
                int green = (i1 >> 8) & 0xFF;
                int blue = (i1 >> 0) & 0xFF;

                if (blue+50 <= 255 && red-50>=0 &&green-50>=0 ){
                    blue =blue+50;
                    red =red-50;
                    green =green-50;
                }
                // 操作三原色值 实现滤镜
                // 冷：blue++
                Color color = new Color (red,green,blue);
                g.setColor(color);
                g.fillRect ( i, j, 1, 1);
            }
        }
    }


    /**
     * 暖色  红+ 其他-
     * 冷色  蓝+ 其他-
     * 黄昏  黄+ 其他-
     * 这个是暖色
     */
    public void draw_warm(Graphics g){
        for(int i = 0; i < imageArray_display.length; i++){
            for(int j = 0; j < imageArray_display[i].length; j++){
                // 取出像素值
                int i1 = imageArray_display[i][j];
                // 拆分为 三原色值
                int red = (i1 >> 16) & 0xFF;
                int green = (i1 >> 8) & 0xFF;
                int blue = (i1 >> 0) & 0xFF;

                if (red+50 <= 255 && blue-50>=0 &&green-50>=0 ){
                    red =red+50;
                    blue =blue-50;
                    green =green-50;
                }
                // 操作三原色值 实现滤镜
                // 冷：blue++

                Color color = new Color (red,green,blue);
                g.setColor(color);
                g.fillRect ( i, j, 1, 1);
            }
        }
    }

    /**
     * 照片底片模式——取反色
     * 灵魂出窍特效
     * 取 255-每个RGB的值
     */
    public void draw_photo_negative(Graphics g){
        for(int i = 0; i < imageArray_display.length; i++){
            for(int j = 0; j < imageArray_display[i].length; j++){
                // 取出像素值
                int i1 = imageArray_display[i][j];
                // 拆分为 三原色值
                int red = (i1 >> 16) & 0xFF;
                int green = (i1 >> 8) & 0xFF;
                int blue = (i1 >> 0) & 0xFF;
                // 操作三原色值 实现滤镜
                // 明暗度 red green blue 等值递减 递加
                // 255-原来的颜色，就是照片底色

                Color color = new Color (255-red,255-green,255-blue);
                g.setColor(color);
                g.fillRect ( i, j, 1, 1);
            }
        }
    }

    /**
     * 生成一个正方形的二维码
     */
    public void draw_Mosaic_trangel(Graphics g){
        // 可以取颜色的范围： 整个整数的范围
        Random ran = new Random ();
        // 绘制一个马赛克_10个长度的
        for(int i = 0; i < 500; i += 10){
            for(int j = 0; j < 500; j += 10){
                Color color = new Color (ran.nextInt (Integer.MAX_VALUE));
                g.setColor (color);
                g.fillRect (i, j, 10, 10);
            }
        }
    }

    /**
     * 给照片加上马赛克效果
     */
    public void draw_Mosaic(Graphics g){

        Random ran = new Random ();
        // 绘制一个马赛克_10个长度的

        int number=0;
        for(int i = 0; i < imageArray_display.length; i++){
            for(int j = 0; j < imageArray_display[i].length; j++){
                // 取出像素值，原本的三原色
                int i1 = imageArray_display[i][j];
                // 拆分为 三原色值
                int red = (i1 >> 16) & 0xFF;
                int green = (i1 >> 8) & 0xFF;
                int blue = (i1 >> 0) & 0xFF;

                // 产生随机数，和原来的加起来
                if ((number&3) ==0){

                    int number_Mosaic =ran.nextInt (Integer.MAX_VALUE);
                    int red_Mosaic = (number_Mosaic >> 16) & 0xFF;
                    int green_Mosaic = (number_Mosaic >> 8) & 0xFF;
                    int blue_Mosaic = (number_Mosaic >> 0) & 0xFF;
                    Color color = new Color (red_Mosaic,green_Mosaic,blue_Mosaic);
                    g.setColor(color);
                }else{
                    Color color = new Color (red,green,blue);
                    g.setColor(color);
                }
                g.fillRect ( i, j, 1, 1);
                number++;
            }
        }
    }


    /**
     * 绘制马赛克 随机噪声色彩矩阵生成
     * @param g
     * @return 随机噪声色彩像素矩阵
     */
    public int[][] get_Mosaic_arry(Graphics g){
        // 可以取颜色的范围： 整个整数的范围
        Random ran = new Random ();
        // 绘制一个马赛克

        // 长度为10的马赛克
        int[][] imgarr_10 = new int[500][500];
        for(int i = 0; i < 500; i += 10){
            for(int j = 0; j < 500; j += 10){
                imgarr_10[i][j] = ran.nextInt (Integer.MAX_VALUE);
                Color color = new Color (imgarr_10[i][j]);
                g.setColor (color);
                g.fillRect (i, j, 10, 10);
            }
        }

//        //长度为1的马赛克
//        int[][] imgarr_1 = new int[500][500];
//        for(int i = 0; i < 500; i += 10){
//            for(int j = 0; j < 500; j += 10){
//                imgarr_1[i][j] = ran.nextInt (Integer.MAX_VALUE);
//                Color color = new Color (imgarr_1[i][j]);
//                g.setColor (color);
//                g.fillRect (i, j, 10, 10);
//            }
//        }

        return imgarr_10;
    }


    /**
     * 画出灰度图像
     * @param imgarr 图像二维数组
     * @param g
     */
    public void draw_gray_Image(int[][] imgarr,Graphics g){
        for(int i = 0; i < imgarr.length; i++){
            for(int j = 0; j < imgarr[i].length; j++){
                // 取出像素值
                int i1 = imgarr[i][j];
                // 拆分为 三原色值
                int red = (i1 >> 16) & 0xFF;
                int green = (i1 >> 8) & 0xFF;
                int blue = (i1 >> 0) & 0xFF;
                // 操作三原色值 实现滤镜
                // 明暗度 red green blue 等值递减 递加
                // gray r=g=b 整个图片就会失去彩色 黑 白 灰度
                int gray = (red + green + blue) / 3;
                 Color color = new Color (gray,gray,gray);
                 g.setColor(color);
                // 灰度化图片 把色彩可以放在一起比较了

//                // 二值化 抠图
//                if(gray < 50){
//                    g.setColor (Color.BLACK);
//                } else{
//                    g.setColor (Color.WHITE);
//                }
                g.fillRect ( i, j, 1, 1);
            }
        }
    }


    /**
     * 画出 二值化处理后的图像
     * @param imgarr 图像二维数组
     * @param g
     */
    public void draw_Image_binarization(int[][] imgarr,Graphics g){
        for(int i = 0; i < imgarr.length; i++){
            for(int j = 0; j < imgarr[i].length; j++){
                // 取出像素值
                int i1 = imgarr[i][j];
                // 拆分为 三原色值
                int red = (i1 >> 16) & 0xFF;
                int green = (i1 >> 8) & 0xFF;
                int blue = (i1 >> 0) & 0xFF;
                // 操作三原色值 实现滤镜
                // 明暗度 red green blue 等值递减 递加
                // gray r=g=b 整个图片就会失去彩色 黑 白 灰度
                int gray = (red + green + blue) / 3;
//                Color color = new Color (gray,gray,gray);
//                g.setColor(color);
                // 灰度化图片 把色彩可以放在一起比较了

                // 二值化 抠图
                if(gray < 55){
                    g.setColor (Color.BLACK);
                } else{
                    g.setColor (Color.WHITE);
                }
                g.fillRect ( i, j, 1, 1);
            }
        }
    }




    /**
     * 根据 缓冲图片对象 转为一个 二维像素数组
     * @param img 传入的图片对象
     * @return 二维像素数组
     */
    public int[][] getImageArray(BufferedImage img){
        // 根据图片的宽高 初始化一个二维数组
        int[][] imgarr = new int[img.getWidth ()][img.getHeight ()];
        // img 对象可以调用的方法
        // 遍历存入 img 对象中取出的像素值
        for(int i = 0; i < img.getWidth (); i++){
            for(int j = 0; j < img.getHeight (); j++){
                int rgb = img.getRGB (i, j);
                imgarr[i][j] = rgb;
            }
        }
        // 返回 二维数组
        return imgarr;
    }


    /**
     * 得到图片
     * 将文件图片读取为一个缓冲图片对象
     */

    public BufferedImage getImage(String path){
        // 根据指定文件路径 创建文件对象
        // 文件是存在磁盘上的一些数据体
        // 文件对象 是内存中的一个对象

        File file = new File (path);
        System.out.println (file.getPath ());
        // 先声明一个缓冲图片 img
        BufferedImage image =null;
        try {

            // IO操作 读取到的缓冲图片对象赋给 img
            image = ImageIO.read (file);
        }catch (Exception e){
            e.printStackTrace ();
        }
        // 方法返回值 img 对象
        return image;
    }


    /**
     *得到原图 画原图
     * @param g
     */
    public void paint_original(Graphics g){
        String path_folder  ="C:\\Users\\lenovo\\Desktop\\img\\";
        String name_img     ="SteveJobs2.jpeg";
        // 其他图片 Spongebob  SteveJobs1 SteveJobs2  rocket
        String str =path_folder + name_img;

        image_display = getImage(str);
        //得到原图
        g.drawImage(image_display,0,0,null);
        //得到这个图片的数组
        imageArray_display=getImageArray(image_display);

        //绘制滤镜


    }