2014-06-07 10:46:19 zhuangxiaobin 阅读数 2445
  • 深度学习--实现图片分析及目标定位视频教学

    基于深度学习实现图片分析及目标定位视频教程,通过计算机视觉和大数据、深度学习的结合,将积累的医学数据转化为可用的模型,利用图像处理和机器学习算法对图像进行分析,检测异常部分,利用AI技术克服不同操作人员之间的主观性差异,减轻人工处理的工作量,让计算机在精确度和速度上帮助医生提高诊断效率。

    1212 人正在学习 去看看 CSDN讲师

这是利用数学算法,进行高难度图像处理的一个例子。事实上,图像处理的数学算法,已经发展到令人叹为观止的地步。

Scriptol列出了几种神奇的图像处理算法,让我们一起来看一下。

一、像素图生成向量图的算法

数字时代早期的图片,分辨率很低。尤其是一些电子游戏的图片,放大后就是一个个像素方块。Depixelizing算法可以让低分辨率的像素图转化为高质量的向量图。

二、黑白图片的着色算法

让老照片自动变成彩色的算法

三、消除阴影的算法

不留痕迹地去掉照片上某件东西的阴影的算法

四、HDR照片的算法

  

 

 

 

所谓"HDR照片",就是扩大亮部与暗部的对比效果,亮的地方变得非常亮,暗的地方变得非常暗,亮暗部的细节都很明显。

实现HDR的软件有很多,这里推荐G'MIC。它是GIMP图像编辑软件的一个插件,代码全部开源。

五、消除杂物的算法

所谓"消除杂物",就是在照片上划出一块区域,然后用背景自动填补。Resynthesizer可以做到这一点,它也是GIMP的一个插件。

六、自动合成照片的算法

根据一张草图,选择原始照片,然后把它们合成在一起,生成新照片。这是清华大学的科研成果

七、美容算法

自动对容貌进行"美化"的算法

 

转载自:http://www.ruanyifeng.com/blog/2011/08/amazing_algorithms_of_image_processing.html

2016-03-10 08:16:02 icamera0 阅读数 110300
  • 深度学习--实现图片分析及目标定位视频教学

    基于深度学习实现图片分析及目标定位视频教程,通过计算机视觉和大数据、深度学习的结合,将积累的医学数据转化为可用的模型,利用图像处理和机器学习算法对图像进行分析,检测异常部分,利用AI技术克服不同操作人员之间的主观性差异,减轻人工处理的工作量,让计算机在精确度和速度上帮助医生提高诊断效率。

    1212 人正在学习 去看看 CSDN讲师

在数字图像处理中,针对不同的图像格式有其特定的处理算法。所以,在做图像处理之前,我们需要考虑清楚自己要基于哪种格式的图像进行算法设计及其实现。本文基于这个需求,使用python中的图像处理库PIL来实现不同图像格式的转换。

对于彩色图像,不管其图像格式是PNG,还是BMP,或者JPG,在PIL中,使用Image模块的open()函数打开后,返回的图像对象的模式都是“RGB”。而对于灰度图像,不管其图像格式是PNG,还是BMP,或者JPG,打开后,其模式为“L”。

通过之前的博客对Image模块的介绍,对于PNGBMPJPG彩色图像格式之间的互相转换都可以通过Image模块的open()save()函数来完成。具体说就是,在打开这些图像时,PIL会将它们解码为三通道的“RGB”图像。用户可以基于这个“RGB”图像,对其进行处理。处理完毕,使用函数save(),可以将处理结果保存成PNGBMPJPG中任何格式。这样也就完成了几种格式之间的转换。同理,其他格式的彩色图像也可以通过这种方式完成转换。当然,对于不同格式的灰度图像,也可通过类似途径完成,只是PIL解码后是模式为“L”的图像。

这里,我想详细介绍一下Image模块的convert()函数,用于不同模式图像之间的转换。

Convert()函数有三种形式的定义,它们定义形式如下:

im.convert(mode) image

im.convert(“P”, **options) image

im.convert(mode, matrix) image

使用不同的参数,将当前的图像转换为新的模式,并产生新的图像作为返回值。

通过博客“Python图像处理库PIL的基本概念介绍”,我们知道PIL中有九种不同模式。分别为1LPRGBRGBACMYKYCbCrIF

本文我采用的示例图像是图像处理中经典的lena照片。分辨率为512x512lena图片如下:

一、模式“RGB”转换为其他不同模式

1、 模式“1

模式“1”为二值图像,非黑即白。但是它每个像素用8bit表示,0表示黑,255表示白。下面我们将lena图像转换为“1”图像。

例子:

>>>from PIL import Image

>>> lena =Image.open("D:\\Code\\Python\\test\\img\\lena.jpg")

>>> lena.mode

'RGB'

>>> lena.getpixel((0,0))

(197, 111, 78)

>>> lena_1 = lena.convert("1")

>>> lena_1.mode

'1'

>>> lena_1.size

(512, 512)

>>>lena_1.getpixel((0,0))

255

>>> lena_1.getpixel((10,10))

255

>>>lena_1.getpixel((10,120))

0

>>>lena_1.getpixel((130,120))

255

 

图像lena_1的模式为“1”,分辨率为512x512,如下:

2、 模式“L

模式“L”为灰色图像,它的每个像素用8bit表示,0表示黑,255表示白,其他数字表示不同的灰度。在PIL中,从模式“RGB”转换为“L”模式是按照下面的公式转换的:

L = R * 299/1000 + G * 587/1000+ B * 114/1000

下面我们将lena图像转换为“L”图像。

例子:

>>> from PIL importImage

>>> lena = Image.open("D:\\Code\\Python\\test\\img\\lena.jpg")

>>> lena.mode

'RGB'

>>> lena.getpixel((0,0))

(197, 111, 78)

>>> lena_L =lena.convert("L")

>>> lena_L.mode

'L'

>>> lena_L.size

(512, 512)

>>>lena.getpixel((0,0))

(197, 111, 78)

>>>lena_L.getpixel((0,0))

132

对于第一个像素点,原始图像lena(197, 111, 78),其转换为灰色值为:

197 *299/1000 + 111 * 587/1000 + 78 * 114/1000 = 132.952PIL中只取了整数部分,即为132

转换后的图像lena_L如下:

3、 模式“P

模式“P”为8位彩色图像,它的每个像素用8bit表示,其对应的彩色值是按照调色板查询出来的。

下面我们使用默认的调色板将lena图像转换为“P”图像。

例子:

>>> from PIL importImage

>>> lena = Image.open("D:\\Code\\Python\\test\\img\\lena.jpg")

>>> lena.mode

'RGB'

>>> lena.getpixel((0,0))

(197, 111, 78)

>>> lena_P =lena.convert("P")

>>> lena_P.mode

'P'

>>>lena_P.getpixel((0,0))

62

 

转换后的图像lena_P如下:

4、 模式“RGBA

模式“RGBA”为32位彩色图像,它的每个像素用32bit表示,其中24bit表示红色、绿色和蓝色三个通道,另外8bit表示alpha通道,即透明通道。

下面我们将模式为“RGB”的lena图像转换为“RGBA”图像。

例子: 

                                                                                                                              

>>> from PIL import Image

>>>lena = Image.open("D:\\Code\\Python\\test\\img\\lena.jpg")

>>>lena.mode

'RGB'

>>>lena.getpixel((0,0))

(197,111, 78)

>>>lena_rgba = lena.convert("RGBA")

>>>lena_rgba.mode

'RGBA'

>>>lena_rgba.getpixel((0,0))

(197,111, 78, 255)

>>>lena_rgba.getpixel((0,1))

(196,110, 77, 255)

>>>lena.getpixel((0,0))

(197,111, 78)

>>>lena.getpixel((0,1))

(196,110, 77)

 

从实例中可以看到,使用当前这个方式将“RGB”图像转为“RGBA”图像时,alpha通道全部设置为255,即完全不透明。

转换后的图像lena_rgba如下:

5、 模式“CMYK

模式“CMYK”为32位彩色图像,它的每个像素用32bit表示。模式CMYK”就是印刷四分色模式,它是彩色印刷时采用的一种套色模式,利用色料的三原色混色原理,加上黑色油墨,共计四种颜色混合叠加,形成所谓“全彩印刷”。

四种标准颜色是:CCyan = 青色,又称为‘天蓝色’或是‘湛蓝’MMagenta = 品红色,又称为‘洋红色’;YYellow = 黄色;KKey Plate(blacK) = 定位套版色(黑色)。

下面我们将模式为“RGB”的lena图像转换为“CMYK”图像。

例子:

>>>from PIL import Image

>>> lena =Image.open("D:\\Code\\Python\\test\\img\\lena.jpg")

>>> lena_cmyk =lena.convert("CMYK")

>>> lena_cmyk.mode

'CMYK'

>>>lena_cmyk.getpixel((0,0))

(58, 144, 177, 0)

>>> lena_cmyk.getpixel((0,1))

(59, 145, 178, 0)

>>>lena.getpixel((0,0))

(197, 111, 78)

>>>lena.getpixel((0,1))

(196, 110, 77)

 

从实例中可以得知PIL中“RGB”转换为“CMYK”的公式如下:

C = 255 - R
M = 255 - G
Y = 255 - B
K = 0

由于该转换公式比较简单,转换后的图像颜色有些失真。

转换后的图像lena_cmyk如下:

6、 模式“YCbCr

模式“YCbCr”为24位彩色图像,它的每个像素用24bit表示。YCbCr其中Y是指亮度分量,Cb指蓝色色度分量,而Cr指红色色度分量。人的肉眼对视频的Y分量更敏感,因此在通过对色度分量进行子采样来减少色度分量后,肉眼将察觉不到的图像质量的变化。

模式“RGB”转换为“YCbCr”的公式如下:

Y= 0.257*R+0.504*G+0.098*B+16
Cb = -0.148*R-0.291*G+0.439*B+128
Cr = 0.439*R-0.368*G-0.071*B+128

下面我们将模式为“RGB”的lena图像转换为“YCbCr”图像。

例子:

>>>from PIL import Image

>>> lena =Image.open("D:\\Code\\Python\\test\\img\\lena.jpg")

>>> lena_ycbcr =lena.convert("YCbCr")

>>>lena_ycbcr.mode

'YCbCr'

>>>lena_ycbcr.getpixel((0,0))

(132, 97, 173)

>>>lena.getpixel((0,0))

(197, 111, 78)

 

按照公式,Y = 0.257*197+0.564*111+0.098*78+16= 136.877

Cb= -0.148*197-0.291*111+0.439*78+128= 100.785
Cr = 0.439*197-0.368*111-0.071*78+128 = 168.097

由此可见,PIL中并非按照这个公式进行“RGB”到“YCbCr”的转换。

转换后的图像lena_ycbcr如下:

7、 模式“I

模式“I”为32位整型灰色图像,它的每个像素用32bit表示,0表示黑,255表示白,(0,255)之间的数字表示不同的灰度。在PIL中,从模式“RGB”转换为“I”模式是按照下面的公式转换的:

I = R * 299/1000 + G * 587/1000 + B * 114/1000

下面我们将模式为“RGB”的lena图像转换为“I”图像。

例子:

>>> from PIL import Image

>>>lena = Image.open("D:\\Code\\Python\\test\\img\\lena.jpg")

>>>lena.getpixel((0,0))

(197,111, 78)

>>>lena.getpixel((0,1))

(196,110, 77)

>>> lena_I =lena.convert("I")

>>> lena_I.mode

'I'

>>>lena_I.getpixel((0,0))

132

>>>lena_I.getpixel((0,1))

131

>>> lena_L =lena.convert("L")

>>>lena_L.getpixel((0,0))

132

>>>lena_L.getpixel((0,1))

131

 

从实验的结果看,模式“I”与模式“L”的结果是完全一样,只是模式“L”的像素是8bit,而模式“I”的像素是32bit

8、 模式“F

模式“F”为32位浮点灰色图像,它的每个像素用32bit表示,0表示黑,255表示白,(0,255)之间的数字表示不同的灰度。在PIL中,从模式“RGB”转换为“F”模式是按照下面的公式转换的:

F = R * 299/1000+ G * 587/1000 + B * 114/1000

下面我们将模式为“RGB”的lena图像转换为“F”图像。

例子:

>>>from PIL import Image

>>> lena =Image.open("D:\\Code\\Python\\test\\img\\lena.jpg")

>>>lena.getpixel((0,0))

(197, 111, 78)

>>>lena.getpixel((0,1))

(196, 110, 77)

>>> lena_F =lena.convert("F")

>>> lena_F.mode

'F'

>>>lena_F.getpixel((0,0))

132.95199584960938

>>>lena_F.getpixel((0,1))

131.95199584960938

 

模式“F”与模式“L”的转换公式是一样的,都是RGB转换为灰色值的公式,但模式“F”会保留小数部分,如实验中的数据。

(未完待续)

2010-05-26 21:46:00 yangfenghero 阅读数 3386
  • 深度学习--实现图片分析及目标定位视频教学

    基于深度学习实现图片分析及目标定位视频教程,通过计算机视觉和大数据、深度学习的结合,将积累的医学数据转化为可用的模型,利用图像处理和机器学习算法对图像进行分析,检测异常部分,利用AI技术克服不同操作人员之间的主观性差异,减轻人工处理的工作量,让计算机在精确度和速度上帮助医生提高诊断效率。

    1212 人正在学习 去看看 CSDN讲师

  灰度拉伸是图像增强的一种,它是把分离的灰度转换到比较集中的程度,这时就更利于分析。

  代码如下:

 

 

 

2012-03-25 16:23:52 jia20003 阅读数 26672
  • 深度学习--实现图片分析及目标定位视频教学

    基于深度学习实现图片分析及目标定位视频教程,通过计算机视觉和大数据、深度学习的结合,将积累的医学数据转化为可用的模型,利用图像处理和机器学习算法对图像进行分析,检测异常部分,利用AI技术克服不同操作人员之间的主观性差异,减轻人工处理的工作量,让计算机在精确度和速度上帮助医生提高诊断效率。

    1212 人正在学习 去看看 CSDN讲师

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


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

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

 

基础知识- 怎么把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);
    }


2013-01-04 11:54:30 lvjing2 阅读数 903
  • 深度学习--实现图片分析及目标定位视频教学

    基于深度学习实现图片分析及目标定位视频教程,通过计算机视觉和大数据、深度学习的结合,将积累的医学数据转化为可用的模型,利用图像处理和机器学习算法对图像进行分析,检测异常部分,利用AI技术克服不同操作人员之间的主观性差异,减轻人工处理的工作量,让计算机在精确度和速度上帮助医生提高诊断效率。

    1212 人正在学习 去看看 CSDN讲师

Scriptol列出了几种神奇的图像处理算法,让我们一起来看一下。

一、像素图生成向量图的算法

数字时代早期的图片,分辨率很低。尤其是一些电子游戏的图片,放大后就是一个个像素方块。Depixelizing算法可以让低分辨率的像素图转化为高质量的向量图。

二、黑白图片的着色算法

让老照片自动变成彩色的算法

三、消除阴影的算法

不留痕迹地去掉照片上某件东西的阴影的算法

四、HDR照片的算法

所谓"HDR照片",就是扩大亮部与暗部的对比效果,亮的地方变得非常亮,暗的地方变得非常暗,亮暗部的细节都很明显。

实现HDR的软件有很多,这里推荐G'MIC。它是GIMP图像编辑软件的一个插件,代码全部开源。

五、消除杂物的算法

所谓"消除杂物",就是在照片上划出一块区域,然后用背景自动填补。Resynthesizer可以做到这一点,它也是GIMP的一个插件。

六、自动合成照片的算法

根据一张草图,选择原始照片,然后把它们合成在一起,生成新照片。这是清华大学的科研成果

七、美容算法

自动对容貌进行"美化"的算法

(完)

原文网址:http://www.ruanyifeng.com/blog/2011/08/amazing_algorithms_of_image_processing.html

友情链接:相似图片搜索

图像处理常用算法

阅读数 672

没有更多推荐了,返回首页