图像处理Image Processing（一）

最新推荐文章于 2023-05-11 08:13:37 发布
最新推荐文章于 2023-05-11 08:13:37 发布
阅读量2.1k 收藏 19
点赞数 3
分类专栏： 一些小项目 文章标签： intellij idea java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45867071/article/details/119860832
版权

目录

一.图像处理的原理

二.图像处理的方法

（1）将图片转换成二维数组

（2）绘制原图

（3）绘制灰度图像

（4）绘制马赛克图像

（5）绘制珠纹化图像

​（6）绘制融合图像

​（7）绘制轮廓图像

（8）绘制黑白版画

（9）绘制锐化图像

（10）绘制高斯模糊图像

 三.锐化、均值模糊、浮雕

一.图像处理的原理

  • 每个图片都可以看做一个保存了每个像素点RGB值的二维数组，我们操作的对象则是RGB值。
  • 每个R、G、B值用1个byte来表示，范围在0~255之间。
  • //rgb数字构成颜色，范围0~255
Color c1 = new Color(123456789);
//int数字构成颜色，int范围即可
Cplor c2 = new Color(111, 222, 111);
  • 每个RGB值都用1个int类型的变量来存储，1个int由4个byte组成，，Color对象由3个byte组成，所以其间可以相互转换。
  • （0，0，0）是黑色，（255，255，255）是白色，（255，0，0）是红色；

二.图像处理的方法

（1）将图片转换成二维数组

  图像处理的本质即为对代表图像的二维数组中的数值按照一定的算法进行重新计算。所以我们首先需要把图片转换成二维数组。

    /**
     *
     * @param path 图片路径
     * @return imgArr 保存图片像素的二维数组
     */
    public int[][] imageFileToArr(String path) {
        File file = new File(path);
        //将图片保存到图像缓冲区
        BufferedImage buffimg = null;
        try {
            buffimg = ImageIO.read(file);
        } catch (Exception e) {
            e.printStackTrace();
        }

        int w = buffimg.getWidth();
        int h = buffimg.getHeight();
        //存储像素点的二维数组
        int[][] imgArr = new int[w][h];

        for(int i = 0; i < w; i++) {
            for(int j = 0; j < h; j++) {
                imgArr[i][j] = buffimg.getRGB(i, j);
            }
        }
        return imgArr;
    }

（2）绘制原图

将图片通过图像缓冲区存储到二维数组以后，我们可以通过遍历，将每个像素点打印出来，从而实现绘制原图的功能。

     //绘制原图
     public void drawImage(int[][] imgArr) {
      
        for(int i = 0; i < imgArr.length; i++) {
            for(int j = 0; j < imgArr[0].length; j++) {

                int rgb = imgArr[i][j];
                Color color = new Color(rgb);
                gr.setColor(color);
                gr.fillRect(i,j,1,1);

            }
        }

实现了绘制原图功能的hxd会发现，图像在窗体的打印十分缓慢，这是因为IO与底层GPU速度不匹配造成的，此时我们进行的是一个一个像素的数据传输，导致图片加载缓慢，关于解决方法我会在后面介绍（在计算时将所有的像素点存入BufferedImage对象，进行全内存操作，然后再绘制）。

（3）绘制灰度图像

实现灰度很简单，三原色R、G、B取相同的值即可以实现灰度，我们一般取平均值。

//绘制灰度图像
    public void drawGrayImage(int[][] imgArr) {
       
        for(int i = 0; i < imgArr.length; i++) {
            for(int j = 0; j < imgArr[0].length; j++) {

                int rgb = imgArr[i][j];
                int red = (rgb >> 16) & 0xFF;
                int green = (rgb >> 8) & 0xFF;
                int blue = (rgb >> 0) & 0xFF;
                int gray = (red + green + blue) / 3;

                Color color = new Color(gray, gray, gray);
                gr.setColor(color);
                gr.drawLine(i, j, i, j);
                
            }
        }
    }

也可以通过如下代码来获取R、G、B的值：

Color c = new Color(rgb);
int r = c.getRed();
int g = c.getGreen();
int b = c.getBlue();

（4）绘制马赛克图像

马赛克图像的实现则是通过扩大像素点-->画方格，来实现的。

    //绘制马赛克图像
    public void drawMosaicImage(int[][] imgArr) {
       
        for(int i = 0; i < imgArr.length; i+=16) {
            for(int j = 0; j < imgArr[0].length; j+=16) {
                Color c2 = new Color(imgArr[i][j]);
                //画方格子，实现方格状马赛克
                gr.setColor(c2);
                gr.fillRect(i, j, 16, 16);
            }
        }
    }

（5）绘制珠纹化图像

珠纹化则是将绘制方格改成了绘制圆；

//绘制珠纹化图像
    public void drawPearlImage(int[][] imgArr) {
       
        for(int i = 0; i < imgArr.length; i+=10) {
            for(int j = 0; j < imgArr[0].length; j+=10) {
                int rgb = imgArr[i][j];
                int red = (rgb >> 16) & 0xFF;
                int green = (rgb >> 8) & 0xFF;
                int blue = (rgb >> 0) & 0xFF;

                Color color = new Color(red, green, blue);
                gr.setColor(color);
                gr.fillOval(i, j, 8, 8);
            }
        }
    }

（6）绘制融合图像

将两个图像融合就是将两个图像的RBG值按照一定的比例组成一个新的RGB的值；

    //绘制融合图像   
    public void drawMixImage(int[][] imgArr, int[][] imgArr2) {
        int w = Math.min(imgArr.length, imgArr2.length);
        int h = Math.min(imgArr[0].length, imgArr2[0].length);
        double pro_1 = 0.4;
        double pro_2 = 0.6;

        for(int i = 0; i < w; i++) {
            for(int j = 0; j < h; j++) {
                int rgb = imgArr[i][j];
                int red = (rgb >> 16) & 0xFF;
                int green = (rgb >> 8) & 0xFF;
                int blue = (rgb >> 0) & 0xFF;

                int rgb2 = imgArr2[i][j];
                int red2 = (rgb2 >> 16) & 0xFF;
                int green2 = (rgb2 >> 8) & 0xFF;
                int blue2 = (rgb2 >> 0) & 0xFF;

                int newRed = (int)(pro_1*red + pro_2*red2);
                int newGreen = (int)(pro_1*green + pro_2*green2);
                int newBlue = (int)(pro_1*blue + pro_2*blue2);

                Color color = new Color(newRed, newGreen, newBlue);
                gr.setColor(color);
                gr.fillRect(i, j, 1, 1);
            }
        }       
    }

（7）绘制轮廓图像

 //绘制轮廓图像
    public void drawOutlinesImage(int[][] imgArr) {
       
        //-3防止越界
        for(int i = 0; i < imgArr.length-3; i++) {
            for(int j = 0; j < imgArr[0].length-3; j++) {

                int rgb = imgArr[i][j];
                int red = (rgb >> 16) & 0xFF;
                int green = (rgb >> 8) & 0xFF;
                int blue = (rgb >> 0) & 0xFF;
                int gray = (red + green + blue) / 3;
                // 获取三个单通道的RGB值
                int rgb2 = imgArr[i+3][j+3];
                int red2 = (rgb2 >> 16) & 0xFF;
                int green2 = (rgb2 >> 8) & 0xFF;
                int blue2 = (rgb2 >> 0) & 0xFF;
                int gray2 = (red2 + green2 + blue2) / 3;
                //边缘检测
                if(Math.abs(gray-gray2) > 5) {
                    gr.setColor(Color.WHITE);
                } else {
                    gr.setColor(Color.BLACK);
                }
                gr.drawLine(i, j, i, j);
            }
        }
    }

（8）绘制黑白版画

rgb值大于某值画黑，小于某值画白；

public void drawBlackWhiteImage(int[][] imgArr) {
     
        for(int i = 0; i < imgArr.length; i++) {
            for(int j = 0; j < imgArr[0].length; j++) {

                int rgb = imgArr[i][j];
                int red = (rgb >> 16) & 0xFF;
                int green = (rgb >> 8) & 0xFF;
                int blue = (rgb >> 0) & 0xFF;
                int gray = (red + green + blue) / 3;
                if(gray > 100) {
                    gr.setColor(Color.WHITE);
                } else {

                    gr.setColor(Color.BLACK);
                }
                gr.drawLine(i, j, i, j);
            }
        }
    }

（9）绘制锐化图像

高斯模糊与图像卷积滤波，这个博客对于图像卷积相关知识讲得还不错，hxdm可以看看；卷积算法就是通过不同的卷积核来处理图像二维数组，从而获取不同的特征图像；

public void drawSharpenImage(int[][] imgArr) {
       
        //锐化卷积核
        float[][] kArr = {
                {-1, -1, -1},
                {-1, 9, -1},
                {-1, -1, -1}
        };
       
        //开始卷积计算
        //tem保存单次卷积核数组乘积的值
        int[][] tem = new int[kArr.length][kArr[0].length];
        //valid为卷积后得到的特征图像的保存数组
        int validWidth = imgArr[0].length - kArr[0].length + 1;
        int validHeihgt = imgArr.length - kArr.length + 1;
        int[][] valid = new int[validHeihgt][validWidth];
        //卷积
        for(int i = 0; i < validHeihgt; i++) {
            for(int j = 0; j < validWidth; j++) {
                for(int y = 0; y < kArr.length; y++) {
                    for(int z = 0; z < kArr[0].length; z++) {
                        tem[y][z] = (int)(imgArr[i+y][j+z] * kArr[y][z]);
                    }
                }
                int k = 0;
                for(int y = 0; y < kArr.length; y++) {
                    for(int z = 0; z < kArr[0].length; z++) {
                        k += tem[y][z];
                    }
                }
                if(k < 0) {
                    k = 0;
                }
                else if(k > 255){
                    k = 255;
                }
                valid[i][j] = (byte)k;
            }
        }

        //打印卷积后的图像
        for(int i = 0; i < valid.length; i++) {
            for(int j = 0; j < valid[0].length; j++) {
                Color c = new Color(valid[i][j]);
                gr.setColor(c);
                gr.drawLine(i, j, i, j);
            }
        }
    }

 此代码我们卷积的对象是保存整个rgb值的二维数组，可以发现，锐化的效果并不理想，作为改进，我们可以把R、G、B三个通道分别卷积然后合成新的图像，效果会更好，后文会讲解。

（10）绘制高斯模糊图像

关于高斯模糊，我们则是通过高斯函数来计算权重矩阵，从而计算模糊值，然后进行高斯模糊。特别要注意边界值的处理，详细情况可以参考（9）中所附链接。

 三.锐化、均值模糊、浮雕

  这三种图像处理的方式都是通过不同的卷积核对图像进行卷积。（R、G、B三个通道分别卷积然后合成新的图像）。

如下是他们的卷积核，可以按照需求修改，不同的卷积核会有不同特征，更大的卷积核效果会更明显。

//卷积核
    //1.锐化卷积核
    float[][] kArr_1 = {
            {-1, -1, -1},
            {-1, 9, -1},
            {-1, -1, -1}
    };
    //2.浮雕卷积核
    float[][] kArr_2 = {
        {-1, -1, 0},
        {-1, 0, 1},
        {0, 1, 1}
    };
    //3.均值模糊卷积核
    float[][] kArr_3 = {
         {0, 0.2f, 0},
         {0.2f, 0, 0.2f},
         {0, 0.2f, 0}
    };

RGB三通道分别卷积的代码如下：

    /**
     *
     * @param imgArr 存储图像的二维数组
     * @param kArr 卷积核二维数组
     * @return buffimg 卷积后的BufferedImage类型图像
     */
    public BufferedImage drawConvolutionImage(int[][] imgArr, float[][] kArr) {
        BufferedImage buffimg = new BufferedImage(imgArr.length, imgArr[0].length, BufferedImage.TYPE_INT_ARGB);
        Graphics bfg = buffimg.getGraphics();

        //三个tem分别保存RGB单次卷积核数组乘积的值
        int[][] temRed = new int[kArr.length][kArr[0].length];
        int[][] temGreen = new int[kArr.length][kArr[0].length];
        int[][] temBlue = new int[kArr.length][kArr[0].length];
        //三个二维数组分别保存三原色的像素
        int[][] redArr = new int[imgArr.length][imgArr[0].length];
        int[][] greenArr = new int[imgArr.length][imgArr[0].length];
        int[][] blueArr = new int[imgArr.length][imgArr[0].length];

        for(int i = 0; i < imgArr.length; i++) {
            for(int j = 0; j < imgArr[0].length; j++) {
                int rgb = imgArr[i][j];
                redArr[i][j] = (rgb >> 16) & 0xFF;
                greenArr[i][j] = (rgb >> 8) & 0xFF;
                blueArr[i][j] = (rgb >> 0) & 0xFF;
            }
        }
        //三个valid二维数组分别保存卷积后特征图像的rgb值
        int validWidth = imgArr[0].length - kArr[0].length + 1;
        int validHeihgt = imgArr.length - kArr.length + 1;
        int[][] validRed = new int[validHeihgt][validWidth];
        int[][] validGreen = new int[validHeihgt][validWidth];
        int[][] validBlue = new int[validHeihgt][validWidth];
        //卷积
        for(int i = 0; i < validHeihgt; i++) {
            for(int j = 0; j < validWidth; j++) {
                for(int y = 0; y < kArr.length; y++) {
                    for(int z = 0; z <kArr[0].length; z++) {
                        temRed[y][z] = (int)(redArr[i+y][j+z] * kArr[y][z]);
                        temGreen[y][z] = (int)(greenArr[i+y][j+z] * kArr[y][z]);
                        temBlue[y][z] = (int)(blueArr[i+y][j+z] * kArr[y][z]);
                    }
                }
                int kRed = 0;
                int kGreen = 0;
                int kBlue = 0;
                for(int y = 0; y < kArr.length; y++) {
                    for(int z = 0; z < kArr[0].length; z++) {
                        kRed += temRed[y][z];
                        kGreen += temGreen[y][z];
                        kBlue += temBlue[y][z];
                    }
                }
                if(kRed < 0) {
                    kRed = 0;
                }
                else if(kRed > 255){
                    kRed = 255;
                }
                if(kGreen < 0) {
                    kGreen = 0;
                }
                else if(kGreen > 255){
                    kGreen = 255;
                }
                if(kBlue < 0) {
                    kBlue = 0;
                }
                else if(kBlue > 255){
                    kBlue = 255;
                }
                validRed[i][j] = kRed;
                validGreen[i][j] = kGreen;
                validBlue[i][j] = kBlue;
            }
        }
        //打印卷积后的图像
        for(int i = 0; i < validHeihgt; i++) {
            for(int j = 0; j < validWidth; j++) {
                Color c = new Color(validRed[i][j], validGreen[i][j], validBlue[i][j]);
                bfg.setColor(c);
                bfg.drawLine(i, j, i, j);
            }
        }
        //窗体上绘制
        gr.drawImage(buffimg, 0, 0, null);
        return buffimg;
    }

Chamberlain T
关注
  • 3
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高效的图像处理云服务-ImageX （image processing）
七脉神剑科技博客
01-13 4285
我最近的关注领域一直是图像处理领域，ImageX 是 火山引擎推出的一款图像处理服务； 对于图像处理服务，一般的APP开发者或者网站开发者其实都不陌生，现在的手机一个用户拍摄了一张图片现在基本都在2-10MB左右，如果一个网站或者APP每次打开一张图片需要加载图片那可真的是太浪费流量了； 所以对于图片的image processing的图片处理特性主要关注的点： 图像基本的裁剪能力； 图像基本的压缩能力 图像加水印能力 增值类的图片处理能力 首先，准备测试账号和测试网站还有测试素材； 测.
Image Processing01：概述
Xchen
08-12 408
Image Processing01：概述总的来说，数字图像处理研究的内容主要包括如下几个方面：1）图像获取和输出 2）图像编码和压缩 3）图像增强与复原 4）图像的频域变换 5）图像的信息安全 6）图像的区域分割 7）图像目标的识别 8）图像目标的跟踪 9）图像的几何变换图像处理的应用领域：1）一些专业图像处理软件：Photoshop、CorelDRAW…… 2）一些手机APP应
计算机视觉Image processing
weixin_44540204的博客
04-24 1726
Image Processing: 1.image filtering: change range of image(可以理解为将图片的pixel范围变小，即颜色光彩度变低) g(x) = t(f(x)) 2.image warping: change domain of image g(x) = f(t(x)) point processiong: The simplest kind of ra...
图像处理（九）-图片和数组的转换
热门推荐
am_student的博客
01-28 1万+
图像处理（九）图片和数组的转换，​ 在深度学习过程中，往往需要制作自己的数据集，相关论文中的现成的数据集尽管可以用来直观地感受算法的效果，但是与自己的项目需求都是有一定出入的。在有大量的图片样本时，我们首先需要读取图片，将其转化为numpy数组，并在控制台打印出来，直观地看到图片对应的矩阵是什么样子的。 ​
图像转换为二维数组存入DSP6748
晨凫追风
05-08 5726
本文为原创作品，转载请注明出处 欢迎关注我的博客：http://blog.csdn.net/hit2015spring和http://www.cnblogs.com/xujianqing/ 这篇博客主要是要讲怎么把一张图片存成一个二进制的文件，直接存到DSP中来做处理，而不用考虑DSP与图像采集模块，或者上位机之间的数据通信使得我们更加专注于算法的开发研究和处理
dd.zip_image processing_图像处理
07-14
说到数字图像处理，不得不提起MATLAB。这是一款非常方便的仿真软件，绝大多数的图像处理可以用MATLAB完成。
Method of Image processing_matlab图像处理_processing_
09-29
Method of Image processing
数字图像处理(Digital Image Processing)
02-26
数字图像处理(Digital Image Processing)是通过计算机对图像进行去除噪声、增强、复原、分割、提取特征等处理的方法和技术。 [1] 数字图像处理的产生和迅速发展主要受三个因素的影响：一是计算机的发展；二是数学的...
ImageProcessing Emgucv图像处理.zip
最新发布
04-14
【项目资源】：包含前端、后端、移动开发、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源等各种技术项目的源码。包括C++、Java、python、web、C#、EDA等项目的源码。 【适用人群】：适用于希望...
数字 图像处理 Digital Image Processing
05-09
数字 图像处理 Digital Image Processing
冈萨雷斯 数字图像处理 MATLAB版.中文版 第二版
10-22
冈萨雷斯 数字图像处理 MATLAB版.中文版 第二版
《OpenCV3 计算机视觉 Python语言实现》——处理文件、摄像头和图形用户界面
c20081052的专栏
10-23 992
2.1.1 读/写图像文件 >>import cv2 >>image = cv2.imread('MyPic.png') >>cv2.imwrite('MyPic.jpg', image) imread()函数的参数： IMREAD_ANYCOLOR=4； IMREAD_ANYDEPTH=2; IMREAD_COLOR=1; IMREAD
Processing大作业——绘画系统
qq_37787956的博客
12-30 1万+
最终迎来了互动媒体最终的大作业，前两次我们分别讨论了，手绘和码绘的区别还有如何进行动态作画。 有兴趣的可以戳下方链接看一看我之前的两次作业。 第一次码绘VS手绘指路：https://blog.csdn.net/qq_37787956/article/details/84200103 码绘VS手绘|processing“运动”主题创作——如何让一只沙雕鸟起飞：https://blog.csdn...
opencv图像和二维数组相互转换
jacke121的专栏
02-28 1万+
opencv图像和二维数组相互转换
【Processing】图像处理框架语言（Hello，Processing！
南方者的博客
12-06 780
在一次偶然摸鱼闲逛，某信突然闪烁，我就知道有人要找我摸鱼了。打开一看，袄！是 “主任” 催我更文...
图像处理Image Processing（二）
超级马里奥 的博客
08-23 639
一.界面概览 这次我们用Java来实现图像处理，先给hxdm上成果： 如图窗体右方（East）面板按钮的所示的功能是我们的图像处理小项目的主要内容。
飞卡日常进度之鹰眼图像解压，转为二维数组
悟已往之不谏 知来者之可追
03-12 1997
摄像头 采集回来的图像是，压缩图像，需要进行解压， 鹰眼图像解压，转为 二维数组。 （其实就是原来一个字节存8个像素点，现在解压把它膨胀成1个字节1个像素点。） 一维数组和二维数组，在内存存储上都是一样的！！！ 图像的存储图：（分辨率60*80）（每行采集80个像素点，共60行，即4800个像素点）（0在左上角，是远方左端） 假设 采集回来的图像地址是： img_bin_buff ...
将图片转换成二维数组的c代码
道亦无名
05-11 697
该代码打开名为 “image.bmp” 的 BMP 格式图片文件，跳过文件头，读取像素数据，然后将像素数据转换为二维数组并打印输出。需要注意的是，该代码将图片的每个像素点的 RGB 值分别存储在一维数组中，所以在将像素数据转换为二维数组时需要注意处理。
Image Processing Toolbox介绍
06-10
Image Processing Toolbox 是由 MATLAB 提供的一个工具箱，用于图像处理和分析。它提供了各种函数和工具，可以用于读取、处理、分析和显示图像。Image Processing Toolbox 可以应用于各种领域，包括计算机视觉、医学图像处理、视觉传感器、自动化和控制系统等。 Image Processing Toolbox 提供了许多常见的图像处理函数，例如图像增强、滤波、分割、形态学操作、特征提取、图像压缩等。此外，它还提供了可视化工具，可以用于显示和分析图像，例如显示图像、绘制图像直方图、测量图像特征等。 除此之外，Image Processing Toolbox 还支持许多不同的图像格式，例如 BMP、JPEG、PNG、TIFF 等。同时，它也可以与其他 MATLAB 工具箱集成使用，例如计算机视觉工具箱、统计和机器学习工具箱等。 总之，Image Processing Toolbox 是一个非常实用和强大的图像处理工具箱，可以帮助用户轻松地处理和分析图像数据。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值