精华内容
下载资源
问答
  • 本篇文章讲解图像灰度化处理的知识,结合OpenCV调用cv2.cvtColor()函数实现图像灰度操作,使用像素处理方法对图像进行灰度化处理。基础性知识希望对您有所帮助。 1.图像灰度化原理 2.基于OpenCV的图像灰度化处理 3....

    该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。希望文章对您有所帮助,如果有不足之处,还请海涵~

    该系列在github所有源代码:https://github.com/eastmountyxz/ImageProcessing-Python
    PS:请求帮忙点个Star,哈哈,第一次使用Github,以后会分享更多代码,一起加油。

    同时推荐作者的C++图像系列知识:
    [数字图像处理] 一.MFC详解显示BMP格式图片
    [数字图像处理] 二.MFC单文档分割窗口显示图片
    [数字图像处理] 三.MFC实现图像灰度、采样和量化功能详解
    [数字图像处理] 四.MFC对话框绘制灰度直方图
    [数字图像处理] 五.MFC图像点运算之灰度线性变化、灰度非线性变化、阈值化和均衡化处理详解
    [数字图像处理] 六.MFC空间几何变换之图像平移、镜像、旋转、缩放详解
    [数字图像处理] 七.MFC图像增强之图像普通平滑、高斯平滑、Laplacian、Sobel、Prewitt锐化详解

    前文参考:
    [Python图像处理] 一.图像处理基础知识及OpenCV入门函数
    [Python图像处理] 二.OpenCV+Numpy库读取与修改像素
    [Python图像处理] 三.获取图像属性、兴趣ROI区域及通道处理
    [Python图像处理] 四.图像平滑之均值滤波、方框滤波、高斯滤波及中值滤波
    [Python图像处理] 五.图像融合、加法运算及图像类型转换
    [Python图像处理] 六.图像缩放、图像旋转、图像翻转与图像平移
    [Python图像处理] 七.图像阈值化处理及算法对比
    [Python图像处理] 八.图像腐蚀与图像膨胀
    [Python图像处理] 九.形态学之图像开运算、闭运算、梯度运算
    [Python图像处理] 十.形态学之图像顶帽运算和黑帽运算
    [Python图像处理] 十一.灰度直方图概念及OpenCV绘制直方图
    [Python图像处理] 十二.图像几何变换之图像仿射变换、图像透视变换和图像校正
    [Python图像处理] 十三.基于灰度三维图的图像顶帽运算和黑帽运算

    本篇文章讲解图像灰度化处理的知识,结合OpenCV调用cv2.cvtColor()函数实现图像灰度操作,使用像素处理方法对图像进行灰度化处理。基础性知识希望对您有所帮助。
    1.图像灰度化原理
    2.基于OpenCV的图像灰度化处理
    3.基于像素操作的图像灰度化处理

    PS:文章参考自己以前系列图像处理文章及OpenCV库函数,同时,本篇文章涉及到《计算机图形学》基础知识,请大家下来补充。

    参考文献:
    杨秀璋等. 基于苗族服饰的图像锐化和边缘提取技术研究[J]. 现代计算机,2018(10).
    《数字图像处理》(第3版),冈萨雷斯著,阮秋琦译,电子工业出版社,2013年.
    《数字图像处理学》(第3版),阮秋琦,电子工业出版社,2008年,北京.
    《OpenCV3编程入门》,毛星云,冷雪飞,电子工业出版社,2015.
    Opencv学习(十六)之颜色空间转换cvtColor()
    python+opencv+图像特效(图像灰度处理、颜色翻转、图片融合,边缘检测,浮雕效果,颜色映射)


    一.图像灰度化原理

    像灰度化是将一幅彩色图像转换为灰度化图像的过程。彩色图像通常包括R、G、B三个分量,分别显示出红绿蓝等各种颜色,灰度化就是使彩色图像的R、G、B三个分量相等的过程。灰度图像中每个像素仅具有一种样本颜色,其灰度是位于黑色与白色之间的多级色彩深度,灰度值大的像素点比较亮,反之比较暗,像素值最大为255(表示白色),像素值最小为0(表示黑色)。

    假设某点的颜色由RGB(R,G,B)组成,常见灰度处理算法如表7.1所示:

    表7.1中Gray表示灰度处理之后的颜色,然后将原始RGB(R,G,B)颜色均匀地替换成新颜色RGB(Gray,Gray,Gray),从而将彩色图片转化为灰度图像。

    一种常见的方法是将RGB三个分量求和再取平均值,但更为准确的方法是设置不同的权重,将RGB分量按不同的比例进行灰度划分。比如人类的眼睛感官蓝色的敏感度最低,敏感最高的是绿色,因此将RGB按照0.299、0.587、0.144比例加权平均能得到较合理的灰度图像,如公式7.1所示。


    二.基于OpenCV的图像灰度化处理

    在日常生活中,我们看到的大多数彩色图像都是RGB类型,但是在图像处理过程中,常常需要用到灰度图像、二值图像、HSV、HSI等颜色,OpenCV提供了cvtColor()函数实现这些功能。其函数原型如下所示:

    dst = cv2.cvtColor(src, code[, dst[, dstCn]])

    • src表示输入图像,需要进行颜色空间变换的原图像
    • dst表示输出图像,其大小和深度与src一致
    • code表示转换的代码或标识
    • dstCn表示目标图像通道数,其值为0时,则有src和code决定

    该函数的作用是将一个图像从一个颜色空间转换到另一个颜色空间,其中,RGB是指Red、Green和Blue,一副图像由这三个通道(channel)构成;Gray表示只有灰度值一个通道;HSV包含Hue(色调)、Saturation(饱和度)和Value(亮度)三个通道。在OpenCV中,常见的颜色空间转换标识包括CV_BGR2BGRA、CV_RGB2GRAY、CV_GRAY2RGB、CV_BGR2HSV、CV_BGR2XYZ、CV_BGR2HLS等。

    下面是调用cvtColor()函数将图像进行灰度化处理的代码。

    #encoding:utf-8
    import cv2  
    import numpy as np  
    
    #读取原始图片
    src = cv2.imread('miao.png')
    
    #图像灰度化处理
    grayImage = cv2.cvtColor(src,cv2.COLOR_BGR2GRAY)
    
    #显示图像
    cv2.imshow("src", src)
    cv2.imshow("result", grayImage)
    
    #等待显示
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    

    输出结果如下图所示,左边是彩色的苗族服饰原图,右边是将彩色图像进行灰度化处理之后的灰度图。其中,灰度图将一个像素点的三个颜色变量设置为相当,R=G=B,此时该值称为灰度值。

    同样,可以调用 grayImage = cv2.cvtColor(src, cv2.COLOR_BGR2HSV) 核心代码将彩色图像转换为HSV颜色空间,如下图所示。

    下面Image_Processing_07_02.py代码对比了九种常见的颜色空间,包括BGR、RGB、GRAY、HSV、YCrCb、HLS、XYZ、LAB和YUV,并循环显示处理后的图像。

    #encoding:utf-8
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img_BGR = cv2.imread('miao.png')
    
    #BGR转换为RGB
    img_RGB = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2RGB)
    
    #灰度化处理
    img_GRAY = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2GRAY)
    
    #BGR转HSV
    img_HSV = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2HSV)
    
    #BGR转YCrCb
    img_YCrCb = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2YCrCb)
    
    #BGR转HLS
    img_HLS = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2HLS)
    
    #BGR转XYZ
    img_XYZ = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2XYZ)
    
    #BGR转LAB
    img_LAB = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2LAB)
    
    #BGR转YUV
    img_YUV = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2YUV)
    
    #调用matplotlib显示处理结果
    titles = ['BGR', 'RGB', 'GRAY', 'HSV', 'YCrCb', 'HLS', 'XYZ', 'LAB', 'YUV']  
    images = [img_BGR, img_RGB, img_GRAY, img_HSV, img_YCrCb,
              img_HLS, img_XYZ, img_LAB, img_YUV]  
    for i in xrange(9):  
       plt.subplot(3, 3, i+1), plt.imshow(images[i], 'gray')  
       plt.title(titles[i])  
       plt.xticks([]),plt.yticks([])  
    plt.show()
    

    其运行结果如图所示:


    三.基于像素操作的图像灰度化处理

    前面讲述了调用OpenCV中cvtColor()函数实现图像灰度化的处理,接下来讲解基于像素操作的图像灰度化处理方法,主要是最大值灰度处理、平均灰度处理和加权平均灰度处理方法。

    1.最大值灰度处理方法
    该方法的灰度值等于彩色图像R、G、B三个分量中的最大值,公式如下:

    其方法灰度化处理后的灰度图亮度很高,实现代码如下。

    #encoding:utf-8
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img = cv2.imread('miao.png')
    
    #获取图像高度和宽度
    height = img.shape[0]
    width = img.shape[1]
    
    #创建一幅图像
    grayimg = np.zeros((height, width, 3), np.uint8)
    
    #图像最大值灰度处理
    for i in range(height):
        for j in range(width):
            #获取图像R G B最大值
            gray = max(img[i,j][0], img[i,j][1], img[i,j][2])
            #灰度图像素赋值 gray=max(R,G,B)
            grayimg[i,j] = np.uint8(gray)
    
    #显示图像
    cv2.imshow("src", img)
    cv2.imshow("gray", grayimg)
    
    #等待显示
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    

    其输出结果如下图所示,其处理效果的灰度偏亮。

    2.平均灰度处理方法
    该方法的灰度值等于彩色图像R、G、B三个分量灰度值的求和平均值,其计算公式如下所示:

    平均灰度处理方法实现代码如下所示:

    #encoding:utf-8
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img = cv2.imread('miao.png')
    
    #获取图像高度和宽度
    height = img.shape[0]
    width = img.shape[1]
    
    #创建一幅图像
    grayimg = np.zeros((height, width, 3), np.uint8)
    print grayimg
    
    #图像平均灰度处理方法
    for i in range(height):
        for j in range(width):
            #灰度值为RGB三个分量的平均值
            gray = (int(img[i,j][0]) + int(img[i,j][1]) + int(img[i,j][2]))  /  3
            grayimg[i,j] = np.uint8(gray)
    
    #显示图像
    cv2.imshow("src", img)
    cv2.imshow("gray", grayimg)
    
    #等待显示
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    

    其输出结果如下图所示:

    3.加权平均灰度处理方法
    该方法根据色彩重要性,将三个分量以不同的权值进行加权平均。由于人眼对绿色的敏感最高,对蓝色敏感最低,因此,按下式对RGB三分量进行加权平均能得到较合理的灰度图像。

    加权平均灰度处理方法实现代码如下所示:

    #encoding:utf-8
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img = cv2.imread('miao.png')
    
    #获取图像高度和宽度
    height = img.shape[0]
    width = img.shape[1]
    
    #创建一幅图像
    grayimg = np.zeros((height, width, 3), np.uint8)
    print grayimg
    
    #图像平均灰度处理方法
    for i in range(height):
        for j in range(width):
            #灰度加权平均法
            gray = 0.30 * img[i,j][0] + 0.59 * img[i,j][1] + 0.11 * img[i,j][2]
            grayimg[i,j] = np.uint8(gray)
    
    #显示图像
    cv2.imshow("src", img)
    cv2.imshow("gray", grayimg)
    
    #等待显示
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    

    其输出结果如下图所示:

    希望文章对大家有所帮助,如果有错误或不足之处,还请海涵。最近连续奔波考博,经历的事情太多,有喜有悲,需要改变自己好好对女神,也希望读者与我一起加油。
    (By:Eastmount 2019-03-25 早上8点 https://blog.csdn.net/Eastmount/)


    2020年8月18新开的“娜璋AI安全之家”,主要围绕Python大数据分析、网络空间安全、人工智能、Web渗透及攻防技术进行讲解,同时分享CCF、SCI、南核北核论文的算法实现。娜璋之家会更加系统,并重构作者的所有文章,从零讲解Python和安全,写了近十年文章,真心想把自己所学所感所做分享出来,还请各位多多指教,真诚邀请您的关注!谢谢。

    展开全文
  • OpenGL像素处理流程

    2012-01-20 06:55:28
    红宝书上的OpenGL像素处理流程简图,内涵丰富。

    红宝书上的OpenGL像素处理流程简图,内涵丰富。


    展开全文
  • HTML5高级编程之像素处理及粒子效果

    万次阅读 多人点赞 2014-03-10 06:33:00
    HTML5中的像素处理,需要用到getImageData和putImageData两个函数,先用getImageData复制canvas画布中的像素数据,然后对获取的像素数据进行处理,最后再通过putImageData将处理完的数据粘贴到canvas画布。...

    HTML5中的像素处理,需要用到getImageData和putImageData两个函数,先用getImageData复制canvas画布中的像素数据,然后对获取的像素数据进行处理,最后再通过putImageData将处理完的数据粘贴到canvas画布。我们不妨把中间处理像素的过程称作像素的批处理,由于像素的复制和粘贴是两个比较费时的过程,为了更高效的对像素进行处理,我们应该在一次批处理过程中尽可能处理更多的像素数据,来减少像素的复制和粘贴这两个操作。

    这听起来似乎是一个相当麻烦的过程,可能有些朋友光是看到上面的几句话估计就已经开始不耐烦了,其实我也是这么认为的,所以我把这一麻烦的过程封装到了lufylegend引擎中的LBitmapData类中,你可以像处理flash的像素一样处理HTML5中的canvas,这听起来是不是很有趣?如果你有兴趣,那么请跟着我一起来看一下这个好玩儿的小功能。

    首先,来认识一下LBitmapData,它通常是用来保存Image对象的,具体用法我就不多说了,大家可以看一下API文档。这里我主要介绍一下如何用它来批量处理像素。

    下面是LBitmapData中的两个函数

    函数功能
    getPixel(x,y,colorType)返回一个表示 BitmapData 对象中在某个特定点 (x, y) 处的 RGB 像素值的数组。其中colorType为需要获取的像素数据的格式,默认为像素数组,当设置成字符串"number"的时候,返回number型的像素
    setPixel(x,y,data)设置 LBitmapData 对象的单个像素。其中data为像素值(支持像素数组,#FF0000,0xFF000等三种格式)

    上面这两个函数是获取和设置单个像素,当我们需要一次性获取或设置一个区域的像素的时候,对应的两个函数如下

    函数功能
    getPixels(rect)返回一组表示 BitmapData 对象中在某个特定区域的 RGB 像素值的数组。其中rect为LRectangle对象,是一个矩形。
    setPixels(rect, data)将像素数据数组转换粘贴到指定的矩形区域。其中data为像素值(支持像素数组,#FF0000,0xFF000等三种格式)

    我们先来准备一张图片,比如下面鄙人这张帅帅的头像,莫吐...

    如果想要把中间比较帅的脸部通过getPixels复制下来,可以像下面这样

    bitmapData = new LBitmapData(imglist["face"]);
    bitmapData.lock();
    var img = bitmapData.getPixels(new LRectangle(75,50,100,100));
    有时候我们需要对LBitmapData进行多次像素的复制和粘贴操作,这个时候可以使用lock函数,它可以将像素数组缓存起来,在这个过程中,所做的所有的像素操作都是对这个缓存数组进行操作,当操作完毕后,调用相应的unlock函数,将操作完的像素数据粘贴回LBitmapData中。

    比如下面这样,我们将复制完的数组中的一部分,分四次粘贴到另外一个LBitmapData的四个不同的位置上。

    bitmapData2 = new LBitmapData(null,0,0,500,400,LBitmapData.DATA_CANVAS);
    bitmapData2.lock();
    bitmapData2.setPixels(new LRectangle(50,30,50,50),img);
    bitmapData2.setPixels(new LRectangle(100,30,50,50),img);
    bitmapData2.setPixels(new LRectangle(150,30,50,50),img);
    bitmapData2.setPixels(new LRectangle(200,30,50,50),img);
    bitmapData2.unlock();

    上面的代码,首先创建了一个空的LBitrmapData对象,最后一个参数是lufylegend-1.8.8版中的新功能,将LBitrmapData对象中保存的数据转换为canvas对象,这样可以提高像素操作的效率。

    执行代码效果如下


    当然,你也可以对这些像素做一些处理,比如下面这样

    bitmapData2.lock();
    var rect = new LRectangle(50,100,100,100);
    var rect1 = new LRectangle(150,100,100,100);
    for(var y=0;y<rect.height;y++){
    	for(var x=0;x<rect.width;x++){
    		var i = y*4*100+x*4;
    		bitmapData2.setPixel(rect.x+rect.width-x,y+rect.y,[img.data[i],img.data[i+1],img.data[i+2],img.data[i+3]]);
    	}
    }
    for(var y=0;y<rect1.height;y++){
    	for(var x=0;x<rect1.width;x++){
    		var i = y*4*100+x*4;
    		bitmapData2.setPixel(x+rect1.x,y+rect1.y,[img.data[i],img.data[i+1],img.data[i+2],img.data[i+3]]);
    	}
    }
    bitmapData2.unlock();
    效果如下

    可以看到,我们成功的通过处理像素,将图片翻转了过来。

    当然图片翻转不需要这么麻烦,在lufylegend.js引擎中,你只需要将对象的属性scaleX设置为-1就可以实现图片的翻转。这里我们主要是为了说明像素的处理很灵活而已。

    好了,有了上面的介绍,我们可以用这些API来制作一个酷酷的粒子效果,效果如下。


    首先,我们先在画布上加一个文本

    var labelText = new LTextField();
    labelText.color = "#000000";
    labelText.weight = "bolder";
    labelText.text = getParameter("k");
    if(!labelText.text)labelText.text="lufylegend.js";
    labelText.size = 50;
    var w = labelText.getWidth()*1.1;
    var h = labelText.size*1.5;
    labelText.width = w;
    labelText.setWordWrap(true,h);
    labelText.x = (LGlobal.width - w)*0.5;
    labelText.y = (LGlobal.height - h)*0.5;
    
    backLayer = new LSprite();
    addChild(backLayer);
    backLayer.addChild(labelText);
    效果如下

    上面唯一需要解释的是下面几行

    var w = labelText.getWidth()*1.1;
    var h = labelText.size*1.5;
    labelText.width = w;
    labelText.setWordWrap(true,h);
    其实只需要用getWidth()和getHeight()就能获取文本的高和宽,但是因为canvas中没有获取文本高度的函数,所以引擎中用了一个不太准确的方式来获取(当然,这一点在引擎下次更新中会得到完美的解决),本次开发,所使用的文本高度和宽度都必须不小于文本的原始大小,所以,我给文本重新设定了一下略大的高度和宽度。
    接下来,我们利用LBitmapData对象的draw函数,把这个文本转换为LBitmapData对象,为什么要转换成LBitmapData对象?请接着往下看,一会儿就知道了。

    bitmapData = new LBitmapData("#000000",0,0,LGlobal.width,LGlobal.height,LBitmapData.DATA_CANVAS);
    bitmapData.draw(backLayer);
    上面的处理其实都是铺垫,不是用来真正显示的,下面再来创建一个LBitmapData空对象,并通过LBitmap将其绘制到canvas画布上

    snowBack = new LBitmapData(null,0,0,LGlobal.width,LGlobal.height,LBitmapData.DATA_CANVAS);
    var bitmap = new LBitmap(snowBack);
    backLayer.addChild(bitmap);
    重点来了,我现在需要对snowBack对象的像素不断的进行处理,这个简单,我们通过ENTER_FRAME来实现

    backLayer.addEventListener(LEvent.ENTER_FRAME,run);
    上面的效果图,可以看到,我需要往画布上不断的添加白色的粒子,就和下雪一样。但是这些白色粒子,不能直接画到画布上,我们需要先将这些粒子添加到一个缓存数组中,然后来批量的操作它们,下面的函数用来生成一个粒子,参数分别是(x坐标,y坐标,下降加速度,x轴方向速度,y轴方向速度)。

    function particle(px,py,ps,pvx,pvy){
    	if(typeof ps == UNDEFINED)ps = 1;
    	if(typeof pvx == UNDEFINED)pvx = 0;
    	if(typeof pvy == UNDEFINED)pvy = 0;
    	_snow.push({x:px,y:py,s:ps,vx:pvx,vy:pvy});
    }
    我们通过不断的调用这个函数,来向画布中不断的添加白色粒子,添加到画布上的粒子,会做向下类似于自由落体的加速运动,在运动过程中会遇到阻碍,就是前面在画面上显示过的文字,当粒子碰到文字的时候,受到阻力,运动变得缓慢,这样粒子在有文字的地方不断的受到文字的阻碍,大量的白色粒子就会聚集到文字处,就形成了上面的粒子效果。

    下面的函数用来检验指定坐标处是否处在文字上

    function checkPixel(x,y){
    	var pixel = bitmapData.getPixel(x,y);
    	for(var i=0;i<pixel.length;i++){
    		if(pixel[i])return true;
    	}
    	return false;
    }
    原理就是获取坐标点像素,然后检验像素点的颜色,现在知道为什么要把前面的文字转换成LBitmapData对象了吧,就是为了要获取指定点的像素值。

    最后,只需要不断的加入白色粒子,然后让粒子不断的向下加速运动就可以了。

    function run(){
    	var n = _snow.length, d;
    	snowBack.lock();
    	snowBack.setPixels(rect,0x000000);
    	while(n--){
    		var p = _snow[n];
    		p.vy += gravity * p.s;
    		p.y += p.vy;
    		if(checkPixel(p.x, p.y)){
    			p.y -= p.vy;
    			p.vy = 0;
    			p.y += 0.2;
    		}
    		snowBack.setPixel(p.x, p.y, 0xffffff);
    		if(p.y > LGlobal.height) {
    			_snow.splice(n, 1);
    		}
    	}
    	snowBack.unlock();
    	n = 10;
    	while(n--) {
    		particle(Math.random() * LGlobal.width, 0, Math.random() + 0.5);
    	}
    }
    好了,大功告成了。

    上面的例子中,文字[lufylegend.js]是固定的,我们还可以再进一步扩展,通过URL设定所需要显示的文字。下面的函数可以用来获取URL中的参数的值。

    function getParameter(key) {
    	var str = location.search.split("?");
    	if (str.length < 2) {
    		return "";
    	}
    	var params = str[1].split("&");
    	for (var i = 0; i < params.length; i++) {
    		var keyVal = params[i].split("=");
    		if (keyVal[0] == key && keyVal.length == 2) {
    			return decodeURIComponent(keyVal[1]);
    		}
    	}
    	return "";
    }
    然后通过调用这个函数来设定文字的值

    labelText.text = getParameter("k");
    好了,大家可以来测试一下了,下面的URL,你可以把后面的文字,改成自己喜欢的任意的字符

    http://lufylegend.com/demo/snow_word/index.html?k=大家好
    效果图




    源码
    其实lufylegend引擎下载包中有源码,不过和本文中略有不同,本文的源码只有一个HTML文件,你直接用浏览器右键就可以看到完整的源码了。


    好了,接下来,请发挥你的想象力,制作更帅更有意思的粒子效果吧

    比如下面的这个比较特别的粒子效果。

    http://lufylegend.com/demo/particle01/


    lufylegend.js引擎官网

    lufylegend.js引擎在线API文档链接


    欢迎继续关注我的博客

    转载请注明:转自lufy_legend的博客http://blog.csdn.net/lufy_legend

    展开全文
  • python图像处理:像素处理

    万次阅读 2018-01-09 16:37:13
    利用Imgae.open()打开图像,再利用PIL对象进行操作。这样只是简单的处理,一旦操作复杂就比较困难。而像素级的处理与许多复杂操作相关。所以,通常我们在加载完图片后,都是把图片转换成矩阵来进行复杂操作。

    利用Imgae.open()打开图像,再利用PIL对象进行操作。这样只是简单的处理,一旦操作复杂就比较困难。而像素级的处理与许多复杂操作相关。所以,通常我们在加载完图片后,都是把图片转换成矩阵来进行复杂操作。

    一般情况,在pyton中进行数字图像处理,都需要导入这些包:

    from PIL import Image
    import numpy as np
    import matplotlib.pyplot as plt

    打开并转换图像成矩阵,并显示:

    from PIL import Image
    import numpy as np
    import matplotlib.pyplot as plt
    img=np.array(Image.open('/home/keysen/caffe/examples/images/cat.jpg')) #打开图像并转化为数字矩阵
    plt.figure('cat')
    plt.imshow(img)
    plt.axis('off')
    plt.show()

    调用numpy中的array()函数就可以将PIL对象转换为数组对象。图片信息:

    print (img.shape)
    print (img.dtype)
    print (img.size)
    print (type(img))

    output

    (360, 480, 3)
    uint8
    518400
    < type ‘numpy.ndarray’ >

    如果是RGB图片,那么转换为array之后,就变成了一个rows*cols*channels的三维矩阵,因此,我们可以使用img[i,j,k]来访问像素值。

    示例1:打开图片,并随机添加一些椒盐噪声

    from PIL import Image
    import numpy as np
    import matplotlib.pyplot as plt
    img=np.array(Image.open('/home/keysen/caffe/examples/images/cat.jpg')) #打开图像并转化为数字矩阵
    
    #随机生成5000个椒盐
    rows,cols,dims=img.shape
    for i in range(5000):
        x=np.random.randint(0,rows)
        y=np.random.randint(0,cols)
        img[x,y,:]=255
    
    plt.figure("cat_salt")
    plt.imshow(img)
    plt.axis('off')
    plt.show()

    output

    这里写图片描述

    示例2:将图像二值化,像素值大于128的变为1,否则变为0

    from PIL import Image
    import numpy as np
    import matplotlib.pyplot as plt
    img=np.array(Image.open('/home/keysen/caffe/examples/images/cat.jpg').convert('L')) #打开图像并转化为数字矩阵
    
    rows,cols=img.shape
    for i in range(rows):
        for j in range(cols):
            if (img[i,j]<=128):
                img[i,j]=0
            else:
                img[i,j]=1
    
    plt.figure("cat_black&white")
    plt.imshow(img,cmap='gray')
    plt.axis('off')
    plt.show()

    output

    这里写图片描述

    如果要对多个像素点进行操作,可以使用数组切片方式访问。切片方式返回的是以指定间隔下标访问该数组的像素值。下面是有关灰度图像的一些例子:

    img[i,:] = im[j,:] # 将第 j 行的数值赋值给第 i 行
    
    img[:,i] = 100 # 将第 i 列的所有数值设为 100
    
    img[:100,:50].sum() # 计算前 100 行、前 50 列所有数值的和
    
    img[50:100,50:100] # 50~100 行,50~100 列(不包括第 100 行和第 100 列)
    
    img[i].mean() # 第 i 行所有数值的平均值
    
    img[:,-1] # 最后一列
    
    img[-2,:] (or im[-2]) # 倒数第二行
    展开全文
  • 在这里我觉得图像处理也就是像素处理像素处理也就是数学计算,我觉得应该多看看Halcon的帮助文档。多看帮助,多学英语。 如:emphasize这个算子,Halcon的帮助文档直接给出了计算方法。 又如:rgb1_to_gray这...
  • Canvas 像素处理之高亮处理

    千次阅读 2017-04-12 10:55:12
    getImageData()方法返回 ImageData 对象,该对象拷贝了画布指定矩形的像素数据。 注意:ImageData对象不是图像,它规定了画布上一个部分(矩形),并保存了该矩形内每个像素的信息。 对于ImageData对象中的每个...
  • (卷积)边缘像素处理

    千次阅读 2019-10-06 16:59:41
    图像进行卷积操作时,图像的边界像素并不能被卷积操作到,原因在于边界像素没有完全跟 kernel 重叠,例如当33滤波时有1个像素的边缘没有被处理,55滤波时有2个像素的边缘没有被处理。 边缘问题解决方法: 在...
  • opencv学习笔记3:像素处理

    千次阅读 2020-07-03 21:25:49
    读取像素 返回值=图像(位置参数) 灰度图读取像素 如 灰度度只有两维 d=img[78,155] print(d) 彩色图读取像素 彩色图 有三个通道。 注意opencv读取的是BGR,非RGB blue=img[78,155,0] green=img[78,150.1] red=...
  • 区域像素可以进行处理,我做了一个鼠标选取两点,将这块区域置零的操作。 import cv2 import numpy as np img = cv2.imread('C:\\Users\\mimi\\Desktop\\1.jpg') a =[] b = [] def on_EVENT_LBUTTONDOWN(event, x, y...
  • Android图片特效处理(像素处理)

    千次阅读 2015-11-04 12:15:35
    这篇博客将会通过对像素的RGB分量做一个处理,然后达到一些特效。并没有很高端大气的代码。也没用使用ImageFilter等一些库。多数参考了别人,大神勿喷。 首先看一下今天的效果图。 由于上传大小限制的关系,只有...
  • MATLAB 读取图片像素处理

    千次阅读 2019-03-20 17:46:37
    %%获取该图片的像素值,3维的 rowscolsm= size(M);%%最后一个是rgb,前两个是分辨率的宽高 maxval=max([rowscolsm(2)/scrwidth rowscolsm(1)/screight]); M=imresize(M,[rowscolsm(1)/maxval rowscolsm(1)...
  • 图片逐像素处理的速度比较

    千次阅读 2006-07-12 15:53:00
    图片逐像素处理的速度比较 这篇文章将介绍对图片进行逐个像素的处理时的方法,由于方法的不同将会造成处理的速度的巨大区别。 以下通过一个例子来说明各种方法的处理速度:我们将一幅200×266像素的图片每个像素的...
  • vb.net 教程 5-13 图像处理之像素处理1

    千次阅读 2017-04-13 19:51:09
    版权声明:本文为博主原创文章,转载请在显著位置标明本文出处以及作者网名,未经作者允许不得用于商业目的。 说实在的,由于效率问题,vb一直对于处理视频、图像之类都处于劣势。...但是还是要先请从像素法开始,因...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,134
精华内容 8,853
关键字:

像素处理