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

已于 2022-03-19 21:20:12 修改
阅读量3.6k 收藏 4
点赞数
分类专栏： 编程基础 文章标签： java 图像处理
于 2022-03-19 18:15:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41025410/article/details/123599506
版权

利用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);

        //绘制滤镜


    }
极客产品经理ZJH
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 图像处理 Opengl美颜滤镜与大眼等功能原理.zip
08-18
C++ 图像处理 Opengl美颜滤镜与大眼等功能原理
java简易美颜相机
m0_52346261的博客
01-21 590
一、图片处理的原理 首先我们知道数码照片只要是存储在计算机上的内容都是二进制码组成，而图片RGB值是由三组byte组成的（ 255.0.0（红色）），所以它可以看成一个整数，红色即为：16711680。 图片数据用int类型二维数组表示。 电脑屏幕显示的图片是由一个个带颜色的小正方形组成的，每个小正方形只有一种颜色（它的值一般是0-16777215之间的一个整数），这样的小正方形就可以说是一个像素点，而我们平时所说的分辨率实际上就是 长 乘 宽 计算出一共能显示多少个像素点（比如1980*1080p
Java实现照片美化：基础功能与技术解析
最新发布
勤劳的小琪
04-22 462
本文介绍了如何使用Java实现照片美化的基础功能，包括亮度和对比度的调整。通过掌握这些基础技术，我们可以对照片进行更多的处理与美化。然而，要实现更高级的照片美化效果，我们可能需要深入研究图像处理算法，并考虑使用更先进的工具和技术。Java作为一种功能强大的编程语言，为照片美化提供了丰富的可能性。通过不断学习和探索，我们可以利用Java实现更多有趣的照片美化功能，为人们带来更好的视觉体验。希望本文能对你有所启发，帮助你更好地理解和应用Java在照片美化领域的应用。
Java美颜相机入门（图像处理实现各种滤镜算法）
weixin_53622554的博客
02-26 929
一款简易美颜相机的功能我们可以简单分为两大块：1.图像处理 2.功能区。
javacv实现图片美颜处理
小筱在线博客
02-01 356
下载和安装OpenCV库：JavaCV是基于OpenCV库的封装，因此需要首先下载和安装OpenCV库。您可以从OpenCV官方网站下载最新的OpenCV版本，并根据安装说明进行安装。导入JavaCV库：在Java项目中导入JavaCV库。您可以在Maven或Gradle等构建工具中添加JavaCV依赖项，或者手动将JavaCV库文件添加到项目的类路径中。请注意，这只是一个简单的示例，并且只实现了简单的美颜效果。加载和处理图片：使用JavaCV加载要处理的图片，并创建一个新的Mat对象来存储处理后的图片。
Java美颜相机基本功能-图片滤镜、处理
LZ2587246324的博客
09-27 96
先实现读取图片功能，创建getImagePixs类，读取图片每个像素点的rgb值到二维数组imgArr[][]，传给paint方法来画出图片。灰化：三原色调为同一个值 = red * 0.30 + green * 0.59 + blue * 0.11。二值黑白：在灰化的基础上设置到达一定值改为白，没到达改为黑。为了实现滤镜，我们只需修改rgb值。反片：《从路飞到黑胡子bushi》马赛克：读取和输出的间隔调为十倍。以下为经过不同修改后的效果。暖滤镜：红、绿加30。增亮:三原色全加30。增暗：三原色全减30。
mysql人像伴随模型_人像美颜算法-皮肤检测
weixin_29705519的博客
02-18 238
为什么要进行皮肤检测美颜的核心处理是磨皮，仅进行模糊平滑处理，对整张图像的处理会显得比较假，如果能针对性的只处理皮肤，效果会更真实。 真实的工程应用中，一张图像的磨皮处理，会分两步走检测出皮肤，生成一个MaskA保边滤波得到图像T根据MaskA，仅对皮肤部位进行滤波处理，非皮肤采用原图像素皮肤检测(or 人像分割)有三大类 · 基于颜⾊空间的⽪肤检测算法· 基于⾼斯模型的肤⾊(⽪肤)概率计算⽅法基...
Java实现android美颜相机源码
10-16
总之，这个Java实现的Android美颜相机源码涵盖了Android Camera API的使用、图像处理技术、面部检测、实时滤镜应用以及用户体验等多个方面的知识。通过深入研究这个项目，开发者可以学习到如何在Android平台上构建...
基于Android的拍照及图像处理——百纳酷相机.zip
02-28
在Android平台上，开发一款基于拍照和图像处理的应用是一项常见的任务，比如百纳酷相机这样的应用。这个项目涉及到了几个关键的技术领域，包括Android原生开发、图像处理算法、以及可能的人工智能应用。下面我们将...
Android 美颜相机 视频滤镜 等效果
05-17
在Android平台上，开发美颜相机和视频滤镜应用是一项常见的任务，涉及到图像处理、计算机视觉以及用户界面设计等多个技术领域。下面将详细讲解这些领域的关键知识点，并结合给出的压缩包文件名来推测可能的项目结构...
强大的Java图像滤镜特效类库Java Image Filters
01-14
Java Image Filters是一款基于Java的图像处理类库，特别是在图像滤镜特效方面，Java Image Filters简直就是强大到天衣无缝。它几乎提供了PS上大部分的图像特效。比如反色特效、图像扭曲、水波和纹理等效果。
毕业设计，实现一个类似美颜相机（美图秀秀应用）的 Android app
09-26
美颜相机通常包括实时美颜、照片编辑和特效添加等功能，而美图秀秀作为一款知名的图像处理应用，其特色在于提供了丰富的美化工具和滤镜效果。 在这个毕业设计项目中，开发者需要掌握以下几个关键知识点： 1. **...
包含美颜等40余种实时滤镜相机，可拍照、录像、图片修改
01-07
在MagicCamera中，美颜功能可能涉及到实时面部识别和图像处理技术，这通常需要高性能的CPU和GPU支持，以及先进的算法如卷积神经网络（CNN）来实现。 其次，40余种实时滤镜是另一个亮点。实时滤镜在拍摄时就能即时...
Java实现图像美颜效果
qq_44836027的博客
08-20 1866
图像原理 对计算机中的一张图片，我们可以将其看成一个宽w*高h的二维数组，即一张图片=int [w][h]，在这个二维数组中每个位置对应着一个int值，它们就是这张图片中每个点的像素值，那么我们要对这张图像做处理，实际上就是对这张图片的二维数组进行操作。下面我们首先来实现将原图显示在界面上吧。 实现原图显示 import java.awt.Color; import java.awt.Graphics; import java.awt.image.BufferedImage; import java.io
JAVA美颜相机入门（兼具图像处理和画图板功能）
xinghuowuyin的博客
02-27 3908
一款简易美颜相机的功能我们可以简单分为两大块：一是对拍摄出的照片可以进行马赛克，美白，灰度调整等功能；二是可以在照片上画圆圈，画直线等涂鸦功能。因此，我们在写代码时，把需要实现的功能分成如下两部分：1、图像处理；2、画板。下面先展示本次完工后美颜相机的效果图：
Java图像处理——美颜相机项目核心
weixin_47349244的博客
03-26 4285
美颜相机项目或者Photoshop的核心就是图像处理。 想要处理图像，首先需要了解图片是怎么在计算机中实现的，即图片原理。
javacv图片美颜处理，视频美颜处理
凌康的博客
06-06 761
国产剧明星演戏自带十级滤镜，是众所周知的秘密； 使用opencv也能实现一定的美颜效果： 代码 二、视频美颜

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值