图像处理之特殊灰度算法技巧

最新推荐文章于 2024-07-21 09:00:00 发布
最新推荐文章于 2024-07-21 09:00:00 发布
阅读量2k 收藏 7
点赞数
分类专栏： Opencv

 - created by gloomyfish

图像处理之特殊灰度算法技巧


介绍几种特殊的灰度算法滤镜，将彩色图像转换为灰度图像。其中涉及到的有基于阈值的图

像二值化，弗洛伊德.斯坦德伯格抖动算法，基于阈值的部分灰度化

 

基础知识- 怎么把RGB转换为单色的[0 ~256]之间的灰度，最常用的转换公式如下：

Gray = 0.299 * red + 0.587 * green + 0.114 * blue;

 

1.       基于像素平均值的图像阈值二值化算法：

处理流程：

a.      首先将彩色图像转换为灰度图像

b.      计算灰度图像的算术平均值– M

c.      以M为阈值，完成对灰度图二值化( 大于阈值M,像素点赋值为白色，否则赋值为黑

色)

图像效果：


关键代码：

public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
    int width = src.getWidth();  
       int height = src.getHeight();  
  
       if ( dest == null )  
           dest = createCompatibleDestImage( src, null );  
       src = super.filter(src, dest);  
  
       int[] inPixels = new int[width*height];  
       int[] outPixels = new int[width*height];  
       getRGB(src, 0, 0, width, height, inPixels );  
         
       // calculate means of pixel    
       int index = 0;    
       double redSum = 0, greenSum = 0, blueSum = 0;    
       double total = height * width;    
       for(int row=0; row<height; row++) {    
           int ta = 0, tr = 0, tg = 0, tb = 0;    
           for(int col=0; col<width; col++) {    
               index = row * width + col;    
               ta = (inPixels[index] >> 24) & 0xff;    
               tr = (inPixels[index] >> 16) & 0xff;    
               tg = (inPixels[index] >> 8) & 0xff;    
               tb = inPixels[index] & 0xff;    
               redSum += tr;    
               greenSum += tg;    
               blueSum +=tb;    
           }    
       }  
       int means = (int)(redSum / total);  
       System.out.println(" threshold average value = " + means);  
         
       // dithering   
       for(int row=0; row<height; row++) {  
        int ta = 0, tr = 0, tg = 0, tb = 0;  
        for(int col=0; col<width; col++) {  
            index = row * width + col;  
            ta = (inPixels[index] >> 24) & 0xff;  
               tr = (inPixels[index] >> 16) & 0xff;  
               tg = (inPixels[index] >> 8) & 0xff;  
               tb = inPixels[index] & 0xff;  
               if(tr >=means) {  
                tr = tg = tb = 255;  
               } else {  
                tr = tg = tb = 0;  
               }  
               outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;  
                 
        }  
       }  
       setRGB( dest, 0, 0, width, height, outPixels );  
       return dest;  
}

2.       基于错误扩散的Floyd-Steinberg抖动算法

关于什么是Floyd-Steinberg抖动，参见这里

http://en.wikipedia.org/wiki/Floyd–Steinberg_dithering

图像效果：

关键代码：

@Override  
public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
    int width = src.getWidth();  
       int height = src.getHeight();  
  
       if ( dest == null )  
        dest = createCompatibleDestImage( src, null );  
       src = super.filter(src, dest);  
  
       int[] inPixels = new int[width*height];  
       int[] outPixels = new int[width*height];  
       getRGB( src, 0, 0, width, height, inPixels );  
       int index = 0;  
       for(int row=0; row<height; row++) {  
        for(int col=0; col<width; col++) {  
            index = row * width + col;  
               int r1 = (inPixels[index] >> 16) & 0xff;  
               int g1 = (inPixels[index] >> 8) & 0xff;  
               int b1 = inPixels[index] & 0xff;  
               int cIndex = getCloseColor(r1, g1, b1);  
               outPixels[index] = (255 << 24) | (COLOR_PALETTE[cIndex][0] << 16) | (COLOR_PALETTE[cIndex][1] << 8) | COLOR_PALETTE[cIndex][2];  
               int er = r1 - COLOR_PALETTE[cIndex][0];  
               int eg = g1 - COLOR_PALETTE[cIndex][1];  
               int eb = b1 -  COLOR_PALETTE[cIndex][2];  
               int k = 0;  
                 
               if(row + 1 < height && col - 1 > 0) {  
                k = (row + 1) * width + col - 1;  
                   r1 = (inPixels[k] >> 16) & 0xff;  
                   g1 = (inPixels[k] >> 8) & 0xff;  
                   b1 = inPixels[k] & 0xff;  
                   r1 += (int)(er * kernelData[0]);  
                   g1 += (int)(eg * kernelData[0]);  
                   b1 += (int)(eb * kernelData[0]);  
                   inPixels[k] = (255 << 24) | (clamp(r1) << 16) | (clamp(g1) << 8) | clamp(b1);  
               }  
                 
               if(col + 1 < width) {  
                k = row * width + col + 1;  
                   r1 = (inPixels[k] >> 16) & 0xff;  
                   g1 = (inPixels[k] >> 8) & 0xff;  
                   b1 = inPixels[k] & 0xff;  
                   r1 += (int)(er * kernelData[3]);  
                   g1 += (int)(eg * kernelData[3]);  
                   b1 += (int)(eb * kernelData[3]);  
                   inPixels[k] = (255 << 24) | (clamp(r1) << 16) | (clamp(g1) << 8) | clamp(b1);  
               }  
                 
               if(row + 1 < height) {  
                k = (row + 1) * width + col;  
                   r1 = (inPixels[k] >> 16) & 0xff;  
                   g1 = (inPixels[k] >> 8) & 0xff;  
                   b1 = inPixels[k] & 0xff;  
                   r1 += (int)(er * kernelData[1]);  
                   g1 += (int)(eg * kernelData[1]);  
                   b1 += (int)(eb * kernelData[1]);  
                   inPixels[k] = (255 << 24) | (clamp(r1) << 16) | (clamp(g1) << 8) | clamp(b1);  
               }  
                 
               if(row + 1 < height && col + 1 < width) {  
                k = (row + 1) * width + col + 1;  
                   r1 = (inPixels[k] >> 16) & 0xff;  
                   g1 = (inPixels[k] >> 8) & 0xff;  
                   b1 = inPixels[k] & 0xff;  
                   r1 += (int)(er * kernelData[2]);  
                   g1 += (int)(eg * kernelData[2]);  
                   b1 += (int)(eb * kernelData[2]);  
                   inPixels[k] = (255 << 24) | (clamp(r1) << 16) | (clamp(g1) << 8) | clamp(b1);  
               }  
        }  
       }  
       setRGB( dest, 0, 0, width, height, outPixels );  
       return dest;  
}

3.       选择性灰度算法

计算选择的颜色与像素灰度颜色之间的几何距离值，跟阈值比较决定是否像素点为灰度

值，可以得到一些让你意想不到的图像处理效果！

图像效果 (Main Color = GREEN, 阈值 = 200)

原图：


public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
    int width = src.getWidth();  
       int height = src.getHeight();  
  
       if ( dest == null )  
        dest = createCompatibleDestImage( src, null );  
  
       int[] inPixels = new int[width*height];  
       int[] outPixels = new int[width*height];  
       getRGB( src, 0, 0, width, height, inPixels );  
       int index = 0;  
       for(int row=0; row<height; row++) {  
        int ta = 0, tr = 0, tg = 0, tb = 0;  
        for(int col=0; col<width; col++) {  
            index = row * width + col;  
            ta = (inPixels[index] >> 24) & 0xff;  
               tr = (inPixels[index] >> 16) & 0xff;  
               tg = (inPixels[index] >> 8) & 0xff;  
               tb = inPixels[index] & 0xff;  
               int gray = (int)(0.299 * (double)tr + 0.587 * (double)tg + 0.114 * (double)tb);  
               double distance = getDistance(tr, tg, tb);  
               if(distance < threshold) {  
                double k = distance / threshold;  
                int[] rgb = getAdjustableRGB(tr, tg, tb, gray, (float)k);  
                tr = rgb[0];  
                tg = rgb[1];  
                tb = rgb[2];  
                outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;  
               } else {  
                outPixels[index] = (ta << 24) | (gray << 16) | (gray << 8) | gray;                      
               }  
                 
        }  
       }  
       setRGB( dest, 0, 0, width, height, outPixels );  
       return dest;  
}  

创建新的目标Image  

public BufferedImage createCompatibleDestImage(BufferedImage src, ColorModel dstCM) {  
    if ( dstCM == null )  
        dstCM = src.getColorModel();  
    return new BufferedImage(dstCM, dstCM.createCompatibleWritableRaster(src.getWidth(), src.getHeight()), dstCM.isAlphaPremultiplied(), null);  
}


年少2
关注
专栏目录
图像处理------特殊灰度算法技巧
南七小僧的学海无涯
08-24 902
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/mao0514/article/details/47036437 介绍几种特殊的灰度算法滤镜，将彩色图像转换为灰度图像。其中涉及到的有基于阈值的图 像二值化，弗洛伊德.斯坦德伯格抖动算法，基于阈值的部分灰度化   基础知识- 怎么把RGB转换为单色的[0 ~256]之间的灰度，最常用的转换公式...
【OpenCV实现图像：用OpenCV图像处理技巧之白平衡算法】
weixin_47869094的博客
11-09 2050
定义了一个函数 calc_color_overcast(image)，该函数用于计算图像中每个颜色通道（红色、绿色、蓝色）的统计信息，包括均值、标准差、最小值、中位数、80th、90th、99th 百分位数以及最大值。其目标是通过缩放图像的颜色通道，使得每个通道中最亮的像素变为白色。通过调整每个通道的亮度，算法可以校正图像的颜色投射，实现图像的白平衡。白平衡是一项用于校正由不同照明条件引起的图像颜色偏差的技术。这个过程非常重要，因为它确保了图像中的颜色是准确的，同时也使图像对人眼来说看起来更加自然。
灰度化处理
09-14
基于Matlab 的灰度化处理工具，比较简单，比较实用，纯粹手打，随便吐槽
python实现误差扩散、Floyd-Steinberg 抖动、有序抖动、Riemersma 抖动算法
最新发布
qq_42568323的博客
07-21 1195
它通过使用预先定义的抖动矩阵（dithering matrix）来量化图像像素，从而在保持图像灰度特性的同时，产生视觉上更平滑的二值图像。有序抖动算法在图像抖动和半色调处理中非常有用，特别适用于需要快速处理和生成二值图像的应用场景，如打印和显示设备。通过选择合适的抖动矩阵，可以在不同应用场景中获得理想的抖动效果。是一种用于图像抖动的技术，通过遍历图像并根据给定的阈值矩阵进行量化。误差扩散算法在图像抖动和半色调处理中非常有用，特别适用于需要将灰度图像转换为二值图像的应用场景，如打印和显示设备。
图像灰度处理四种基本算法及优化
做自己喜欢的事情就好啦
01-12 2363
文章目录算法一1. imread算法二2. cvtColor算法三3. RGB R=G=B (R+G+B)/3算法四4. gray = r * 0.299+g * 0.587+b * 0.114性能优化5. 算法优化 算法一 1. imread #imread #方法1 imread import cv2 img0 = cv2.imread('image0.jpg',0) img1 = cv2.imread('image0.jpg',1) print(img0.shape) print(img1.sha
一、图片灰度算法
怪蜀黍
07-03 5465
文章目录灰度算法简介一.opencv灰度实现二.灰度算法手动实现 灰度算法简介 在计算机领域中，灰度（Gray scale）数字图像是每个像素只有一个采样颜色的图像。这类图像通常显示为从最暗黑色到最亮的白色的灰度，尽管理论上这个采样可以是任何颜色的不同深浅，甚至可以是不同亮度上的不同颜色。灰度图像与黑白图像不同，在计算机图像领域中黑白图像只有黑白两种颜色，灰度图像在黑色与白色之间还有许多级的颜色...
灰度图像算法
我的杂物间
06-01 1781
一、基础 　　对于彩色转灰度，有一个很著名的心理学公式：        Gray = R*0.299 + G*0.587 + B*0.114 二、整数算法 　　而实际应用时，希望避免低速的浮点运算，所以需要整数算法。 　　注意到系数都是3位精度的没有，我们可以将它们缩放1000倍来实现整数运算算法： Gray = (R*299 + G*587 + B*114 + 500) /
图像处理灰度变换实验.doc
10-08
【图像处理灰度变换实验】 图像处理中，灰度变换是一种基本且强大的技术，用于改善图像的视觉效果和对比度。这个实验旨在让学习者熟悉并掌握如何在MATLAB环境中进行数字图像处理，包括图像的读取、写入、显示以及...
【学生作业】数字图像处理之MATLAB大作业：自制图像处理小工具
Daxxuan5050的博客
11-23 6321
本文为一个刚入门 MATLAB 的学生所写，内容是使用 APP Designer 做一个 GUI 界面的图像处理的小工具。还有很多不足，欢迎批评指正。
图像处理 灰度世界算法
qq_43437044的博客
11-30 3586
灰度世界算法是以灰度世界假设为基础的，该假设认为对于一幅有着大量色彩变化的图像, R、 G、 B 三个分量的平均值趋于同一个灰度K。 从物理意义上讲，灰色世界法假设自然界景物对于光线的平均反射的均值在总体上是个定值，这个定值近似地为“灰色”。颜色平衡算法将这一假设强制应用于待处理图像，可以从图像中消除环境光的影响。 步骤： 1.通过计算图像R,G,B三通道平均值avgR，avgG，avgB 2.计算三个通道的增益系数 ; ; ； 3.根据对角模型，对于图像的每个像素C，调整分量 ...
灰度模型计算方法
04-01
此为计算灰度模型时所需要的程序代码加注释
RTCP图像灰度化算法
04-03
RTCP图像灰度化算法，可以更完美的保证图像灰度化后更多色彩信息，在opencv2下使用，3没测试过！！！
改进的灰度预测算法
05-21
对数据做了优化处理的灰色预测模型。通过数据优化，满足灰色预测的级比要求。
图像的灰度处理
吃葡萄不吐葡萄皮
06-26 2752
1. 亮度法（Luminosity Method）：灰度图像的亮度法是通过对彩色图像的RGB通道进行加权平均来计算灰度值。与亮度法不同的是，加权平均法使用了不同的权重系数，通常使用以下公式计算每个像素的灰度值，该方法简单地对三个通道进行均值计算，没有考虑人眼对不同通道的敏感度差异。1. 降低数据维度：彩色图像通常包含了大量的冗余信息，而灰度图像只保留了图像的亮度信息。灰度处理的原理是将彩色图像转换为灰度图像，即将每个像素的颜色信息转换为单一的灰度值。
图像灰度化处理
crossoverpptx的博客
10-11 2万+
在RGB模型中，如果R=G=B时，则彩色表示一种灰度颜色，其中R=G=B的值叫灰度值，因此，灰度图像每个像素只需一个字节存放灰度值（又称强度值、亮度值），灰度范围为0-255，当灰度为255的时候，表示最亮（纯白）；当灰度为0的时候，表示最暗（纯黑）。灰度化的好处是：相较于彩色图像灰度图像占内存更小，运行速度更快；灰度图像后可以在视觉上增加对比，突出目标区域。
灰度算法
不知道是谁的专栏
07-12 1589
灰度算法是将彩色图片转换为灰度值的算法。 主要原理是将一个像素点的rgb值乘以一定的系数，然后在将结果分别重新赋给rbg，朴素的灰度算法系数是gray=r*0.299+g*0.587+b*0.114 另外还有几种灰度算法的变异，参见http://blog.csdn.net/jia20003/article/details/7392325
灰度世界算法（Gray World Algorithm）和White Patch Retinex算法
热门推荐
盛夏光年
02-24 2万+
灰度世界算法（Gray World Algorithm） 人的视觉系统具有颜色恒常性，能从变化的光照环境和成像条件下获取物体表面颜色的不变特性，但成像设备不具有这样的调节功能， 不同的光照环境会导致采集的图像颜色与真实颜色存在一定程度的偏差，需要选择合适的颜色平衡（校正）算法，消除光照环境对颜 色显现的影响。灰度世界算法是最常用平衡算法。 一、灰度世
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值