精华内容
下载资源
问答
  • 内有下载链接 图像识别:图像的灰度化和二值化,图像识别:图像的灰度化和二值化
  • 用matlab来实现图像的灰度化和二值化两个基本功能
  • opencv图像处理之灰度化和二值化

    千次阅读 2019-11-29 10:28:09
    本篇文章将通过灰度化和二值化&二值图像的腐蚀和膨胀的原理来介绍opencv图像处理 灰度化和二值化 1.1、图像二值化基本原理: 对灰度图像进行处理,设定阈值,在阈值中的像素值将变为1(白色部分),阈值为的将...
        

    阿里P7移动互联网架构师进阶视频(每日更新中)免费学习请点击:https://space.bilibili.com/474380680

    本篇文章将通过灰度化和二值化&二值图像的腐蚀和膨胀的原理来介绍opencv图像处理

    灰度化和二值化

    1.1、图像二值化基本原理:

    对灰度图像进行处理,设定阈值,在阈值中的像素值将变为1(白色部分),阈值为的将变为0(黑色部分)。

    1.2、图像二值化处理步骤:

    (1)先对彩色图像进行灰度化

    //img为原图,imgGray为灰度图
    cvtColor(img, imgGray, CV_BGR2GRAY);
    

    (2)对灰度图进行二值化

    //imgGray为灰度图,result为二值图像
    //100~255为阈值,可以根据情况设定
    //在阈值中的像素点将变为0(白色部分),阈值之外的像素将变为1(黑色部分)。
    threshold(imgGray, result, 100, 255, CV_THRESH_BINARY);
    

    1.3、demo

    #include<iostream>
    #include<opencv2\highgui\highgui.hpp>
    #include<opencv2\core\core.hpp>
    #include <opencv2\imgproc\imgproc.hpp>
     
    using namespace std;
    using namespace cv;
     
    int main()
    {
        Mat img, imgGray,result;
        img = imread("test.jpg");
        if (!img.data) {
            cout << "Please input image path" << endl;
            return 0;
        }
        imshow("原图", img);
        cvtColor(img, imgGray, CV_BGR2GRAY);
        imshow("灰度图", imgGray);
        //blur(imgGray, imgGray, Size(3, 3));
        threshold(imgGray, result, 100, 255, CV_THRESH_BINARY);
        imshow("二值化后的图", result);
        imwrite("二值化的二维码.jpg", result);
        cout << "图片已保存" << endl;
        waitKey();
     
        return 0;
    }
    

    1.4、效果:

    19956127-0e08fb5e8316a0f4.png

    二、腐蚀与膨胀

    2.1 腐蚀的原理:

    二值图像前景物体为1,背景为0.假设原图像中有一个前景物体,那么我们用一个结构元素去腐蚀原图的过程是这样的:遍历原图像的每一个像素,然后用结构元素的中心点对准当前正在遍历的这个像素,然后取当前结构元素所覆盖下的原图对应区域内的所有像素的最小值,用这个最小值替换当前像素值。由于二值图像最小值就是0,所以就是用0替换,即变成了黑色背景。从而也可以看出,如果当前结构元素覆盖下,全部都是背景,那么就不会对原图做出改动,因为都是0.如果全部都是前景像素,也不会对原图做出改动,因为都是1.只有结构元素位于前景物体边缘的时候,它覆盖的区域内才会出现0和1两种不同的像素值,这个时候把当前像素替换成0就有变化了。因此腐蚀看起来的效果就是让前景物体缩小了一圈一样。对于前景物体中一些细小的连接处,如果结构元素大小相等,这些连接处就会被断开。

    2.2 膨胀的原理:

    二值图像前景物体为1,背景为0.假设原图像中有一个前景物体,那么我们用一个结构元素去膨胀原图的过程是这样的:遍历原图像的每一个像素,然后用结构元素的中心点对准当前正在遍历的这个像素,然后取当前结构元素所覆盖下的原图对应区域内的所有像素的最大值,用这个最大值替换当前像素值。由于二值图像最大值就是1,所以就是用1替换,即变成了白色前景物体。从而也可以看出,如果当前结构元素覆盖下,全部都是背景,那么就不会对原图做出改动,因为都是0.如果全部都是前景像素,也不会对原图做出改动,因为都是1.只有结构元素位于前景物体边缘的时候,它覆盖的区域内才会出现0和1两种不同的像素值,这个时候把当前像素替换成1就有变化了。因此膨胀看起来的效果就是让前景物体胀大了一圈一样。对于前景物体中一些细小的断裂处,如果结构元素大小相等,这些断裂的地方就会被连接起来。
    参考
    https://blog.csdn.net/chenyuping333/article/details/81483593
    https://blog.csdn.net/woainishifu/article/details/60778033
    阿里P7移动互联网架构师进阶视频(每日更新中)免费学习请点击:https://space.bilibili.com/474380680

    展开全文
  • 图像灰度化和二值化在图像识别里面经常使用,这里以HLS实现整个过程 一、实现功能: 读取一张bmp图片,输出一张灰度化bmp图片和二值化后的黑白图片 二、需要用到的接口 1、读写图片工具函数bmp_tools.cpp 这里我们用...

    图像灰度化和二值化在图像识别里面经常使用,这里以HLS实现整个过程

    一、实现功能:
    读取一张bmp图片,输出一张灰度化bmp图片和二值化后的黑白图片

    二、需要用到的接口
    1、读写图片工具函数bmp_tools.cpp
    这里我们用现成的
    2、输入输出流接口传递像素点

    三、思路
    整体写两个模块,
    1.一个用于彩色图片灰度化,
    2.另一个用于灰度化图片二值化
    然后编写主函数去读取图片通过流接口传入传出并写出图片显示

    主函数流程
    1、读取图片
    2、将一维数组的像素点写到in_img_s流里面
    3、灰度化处理 公式 gray = 0.299r + 0.578g + 0.114*b
    4、二值化处理 输入为阈值 输入流 输出流 行 列 ;公式 ·y = gray > x ? 255 : 0
    5、从输出流里面把像素点读取到一维数组
    6、把一维数组的像素点写进图片
    7、释放内存

    灰度化流程
    1、将输入流里面的像素点读取出来 到
    2、把predata的r g b拆分出来,拆分成4个字节
    3、代入计算公式,计算灰度值gray = 0.299r + 0.578g + 0.114b
    4、把灰度值分别放到r、g、b
    5、设定上限,限制到255
    6、将r 、g、b合并成unsigned int 像素点
    7、将像素点写进输出流

    二值化流程
    1、将输入流里面的像素点读取出来 到
    2、代入公式 y = gray > x ? 255 : 0
    3、生成 unsigned int 像素点
    4、将像素点写进输出流

    四、编写代码
    main.cpp

    #include <stdio.h>
    #include <stdlib.h>
    #include "HLS/hls.h"
    #include "bmp_tools.h"
    #include "gray.h"
    #include "banary.h"
    
    
    unsigned int *img_in;
    unsigned int *img_out1;
    unsigned int *img_out2;
    int rows,cols;
    std::string input_bmp_filename = "tiananmen.bmp";
    std::string output1_bmp_filename = "gray.bmp";
    std::string output2_bmp_filename = "banary.bmp";
    
    //typedef ihc::stream_in<unsigned int> input_image_stream;
    //typedef ihc::stream_out<unsigned int> output_image_stream;
    
    int main()
    {
    	input_image_stream in_img_s;
    	output_image_stream out1_img_s;
    	output_image_stream out2_img_s;
    	
    	//一、读取图片
    	read_bmp (input_bmp_filename.c_str(), &img_in, rows, cols);
    	printf("1\n");
    	
    	//二、将一维数组的像素点写到in_img_s流里面
    	for(int i = 0; i < (rows*cols); i++)
    	{
    		in_img_s.write(img_in[i]);
    	}
    	printf("2\n");
    	//三、灰度化处理 公式 gray = 0.299r + 0.578g + 0.114b
    	gray_deal(in_img_s, out1_img_s, rows, cols);
    	printf("3\n");
    	img_out1 = (unsigned int *)malloc(rows*cols*sizeof(unsigned int));
    	for(int j = 0; j < (rows*cols); j++)
    	{
    		img_out1[j] = out1_img_s.read();
    	}
    	for(int j = 0; j < (rows*cols); j++)
    	{
    		out1_img_s.write(img_out1[j]);
    	}
    	
    	//四、二值化处理 输入为阈值 输入流 输出流 行 列 ;公式 ·y = gray > x ? 255 : 0 
    	banary_deal(out1_img_s, out2_img_s, rows, cols);
    	printf("4\n");
    	
    	//五、从输出流里面把像素点读取到一维数组
    	img_out2 = (unsigned int *)malloc(rows*cols*sizeof(unsigned int));
    	for(int k = 0; k < (rows*cols); k++)
    	{
    		img_out2[k] = out2_img_s.read();
    	}
    	printf("5\n");
    	
    	//六、把一维数组的像素点写进图片
    	write_bmp (output1_bmp_filename.c_str(), img_out1, rows, cols);
    	write_bmp (output2_bmp_filename.c_str(), img_out2, rows, cols);
    	printf("6\n");
    	//七、释放内存
    	free(img_in);
    	free(img_out1);
    	free(img_out2);
    	printf("7\n");
    	return 0;
    }
    

    gray.cpp

    #include "HLS/hls.h"
    #include <stdio.h>
    #include <stdlib.h>
    #include "gray.h"
    
    component void gray_deal(input_image_stream &input, output_image_stream &out, int rows, int cols)
    {
    	unsigned char rgb[4];
    	unsigned char gray_tmp;
    	
    	#pragma unroll
    	for(int i = 0; i < (rows * cols); i++)
    	{
    		//1、将输入流里面的像素点读取出来 到predata
    		unsigned int img_date = input.read();
    		//2、把predata的r g b拆分出来,拆分成4个字节
    		rgb[0] = img_date & 0xff;//蓝色字节
    		rgb[1] = (img_date >> 8) & 0xff;//绿色字节
    		rgb[2] = (img_date >> 16) & 0xff;//红色字节
    		rgb[3] = 0;
    		//3、代入计算公式,计算灰度值gray = 0.299r + 0.578g + 0.114b
    		gray_tmp = 0.299*rgb[2] + 0.578*rgb[1] + 0.114*rgb[0];
    		//4、把灰度值分别放到r、g、b
    		rgb[0] = gray_tmp;
    		rgb[1] = gray_tmp;
    		rgb[2] = gray_tmp;
    		//5、设定上限,限制到255
    		//--
    		//6、将r 、g、b合并成unsigned int 像素点
    		img_date = 0;
    		img_date = ((unsigned int )rgb[2] << 16);
    		img_date = img_date | ((unsigned int )rgb[1] << 8);
    		img_date = img_date | rgb[0];
    		//7、将像素点写进输出流
    		out.write(img_date);
    	}
    }
    

    gray.h

    #ifndef __GRAY_H
    #define __GRAY_H
    
    typedef ihc::stream_in<unsigned int> input_image_stream;
    typedef ihc::stream_out<unsigned int> output_image_stream;
    component void gray_deal(input_image_stream &input, output_image_stream &out, int rows, int cols);
    
    #endif
    

    banary.cpp

    #include "HLS/hls.h"
    #include <stdio.h>
    #include <stdlib.h>
    #include "banary.h"
    
    #define XX 150
    
    component void banary_deal(output_image_stream &gray, output_image_stream &b_out, int rows, int cols)
    {
    	for(int i = 0; i < (rows * cols); i++)
    	{
    		//1、将输入流里面的像素点读取出来 到predata   灰度值
    		unsigned int img_data = gray.read();
    		unsigned char tmp = img_data & 0xff;
    		unsigned char banary = 0;
    		
    		//2、代入公式 y = gray > x ? 255 : 0 
    		banary = tmp > XX ? 255 : 0; 
    		
    		//3、生成 unsigned int 像素点
    		img_data = 0;
    		img_data = banary;//蓝色部分
    		img_data = img_data | ((unsigned int )banary << 8);//绿色部分
    		img_data = img_data | ((unsigned int )banary << 16);//红色部分
    		
    		//4、将像素点写进输出流
    		b_out.write(img_data);
    	}
    }
    

    banary.h

    #ifndef __BANARY_H
    #define __BANARY_H
    
    typedef ihc::stream_in<unsigned int> input_image_stream;
    typedef ihc::stream_out<unsigned int> output_image_stream;
    component void banary_deal(output_image_stream &gray, output_image_stream &b_out, int rows, int cols);
    
    #endif
    

    bmp_tools.cpp

    // bmp_tools.cpp
    
    #include "bmp_tools.h"
    #include <stdio.h>
    #include <stdlib.h>
    
    // Bitmap header size in bytes
    static const int BMP_HEADER_SIZE = 54;
    
    void read_bmp (const char* filename, unsigned int** img_data, int& height, int& width) {
      FILE *fp;
      if ((fp=fopen(filename,"rb"))==NULL) {
        printf("can't open file %s for binary reading\n", filename);
        exit(1);
      }
    
      // Skip over unimportant parts of header
      for (int i=0; i<18; i++) fgetc(fp); 
      
      //read width and height
      fread(&width, sizeof(int), 1, fp);
      fread(&height, sizeof(int), 1, fp);
      if (height < 0 || width < 0) {
        printf("error got height %d, width %d\n", height, width);
        exit(1);
      }
      printf("image size is %d (width) by %d (height) pixels\n", width, height);
      *img_data = (unsigned int*) malloc(width * height * sizeof(unsigned int));
    	
      // Skip remaining part of header
      for (int i=0; i<28; i++) fgetc(fp);
      
      // BMP: Each line must be a multiple of 4 bytes
      int padding = (4-((width*3)&3))&3;
      int idx=0;      
      // Color order is BGR, read across bottom row, then repeat going up rows
      for (int i=0; i< height; ++i) {
    	  for (int j=0; j< width; ++j) {
          unsigned char b = fgetc(fp); //B
          unsigned char g = fgetc(fp); //G
          unsigned char r = fgetc(fp); //R
          (*img_data)[idx] = (((unsigned int ) r << 16) | ((unsigned int ) g << 8) | ((unsigned int ) b << 0));
          idx++;
    	  }
    	  // Discard the padding bytes
    	  for (int j=0; j< padding; ++j) {
    	  	unsigned char b = fgetc(fp);
    	  }
      }
      fclose(fp);
    }
    
    void write_bmp (const char* filename, unsigned int* img_data, int& height, int& width) {
      FILE *fp;
      unsigned int file_size = width * height * 3 + BMP_HEADER_SIZE;
      unsigned char header[BMP_HEADER_SIZE] = { 0x42, 0x4d,         // BMP & DIB
                                            (file_size & 0xff), ((file_size >> 8) & 0xff), ((file_size >> 16) & 0xff), ((file_size >> 24) & 0xff), // size of file in bytes
                                            0x00, 0x00, 0x00, 0x00, // reserved
                                            0x36, 0x00, 0x00, 0x00, // offset of start of image data
                                            0x28, 0x00, 0x00, 0x00, // size of the DIB header
                                            (width & 0xff), ((width >> 8) & 0xff), ((width >> 16) & 0xff), ((width >> 24) & 0xff),     // width in pixels
                                            (height & 0xff), ((height >> 8) & 0xff), ((height >> 16) & 0xff), ((height >> 24) & 0xff), // height in pixels
                                            0x01, 0x00, // number of color planes
                                            0x18, 0x00, // number of bits per pixel
                                            0x00, 0x00, 0x00, 0x00, // no compression - BI_RGB
                                            0x00, 0x00, 0x00, 0x00, // image size - dummy 0 for BI_RGB
                                            0x13, 0x0b, 0x00, 0x00, // horizontal ppm
                                            0x13, 0x0b, 0x00, 0x00, // vertical ppm
                                            0x00, 0x00, 0x00, 0x00, // default 2^n colors in palatte
                                            0x00, 0x00, 0x00, 0x00  // every color is important
                                          };
      // Open file for write
      if ((fp=fopen(filename,"wb"))==NULL) { 
        printf("can't open file %s for binary writing\n", filename); 
        exit(1);
      }
    
      // Write header
      fwrite(header, 1, BMP_HEADER_SIZE, fp);
    
      // Write data: Line size must be a multiple of 4 bytes
      int padding = (4-((width*3)&3))&3;
      int idx = 0;
      for (int i = 0; i <  height; ++i) {
        unsigned char p[3];
        for (int j = 0; j < width ; ++j) {
          // written in B, G, R order
          p[0] = (img_data[idx] >>  0) & 0xff; //B
          p[1] = (img_data[idx] >>  8) & 0xff; //G
          p[2] = (img_data[idx] >> 16) & 0xff; //R
          idx++;
          fwrite(p, 1, 3, fp);
        }
        // Pad to multiple of 4 bytes
        if (padding) {
        	p[0]=p[1]=p[2]=0;
        	fwrite(p,1,padding,fp);
        }
      }
      fclose(fp);
    }
    
    

    bmp_tools.h

    // bmp_tools.h
    #ifndef BMP_TOOLS_H
    #define BMP_TOOLS_H
    
    void read_bmp (const char* filename, unsigned int** img_data, int& height, int& width);
    void write_bmp (const char* filename, unsigned int* img_data, int& height, int& width);
    
    #endif // BMP_TOOLS_H
    
    

    五、编译
    i++ -march=x86-64 -o img main.cpp bmp_tool.cpp gray.cpp banary.cpp

    六、运行测试
    在这里插入图片描述
    首先需要添加输入图片的名字,注意必须是24位深度的bmp图片
    输入img.exe
    然后打开看生成的图片
    这里是我这里的结果
    原图
    在这里插入图片描述
    灰度化
    在这里插入图片描述
    二值化
    在这里插入图片描述

    展开全文
  • opencv实现图像灰度化和二值化

    热门讨论 2011-03-04 14:57:32
    基于开源的opencv,实现一个图像的灰度化和二值化。用于后续的图像分割和识别
  • C#和EmguCV实现图像灰度化和二值化(VS2010窗体+代码)。学生一枚,虚心接受批评。
  • 图像处理的灰度化和二值化

    万次阅读 2018-08-03 09:28:06
    图像处理的灰度化和二值化  (2016-12-07 16:17:07) 转载▼ 标签:  图像处理 分类: 人工智能和大数据  在图像处理中,用RGB三个分量(R:Red,G:Green,B:Blue),即红、绿、蓝三原色来表示...

    图像处理的灰度化和二值化

     (2016-12-07 16:17:07)

    转载

    标签: 

    图像处理

    分类: 人工智能和大数据

           在图像处理中,用RGB三个分量(R:Red,G:Green,B:Blue),即红、绿、蓝三原色来表示真彩色,R分量,G分量,B分量的取值范围均为0~255,比如电脑屏幕上的一个红色的像素点的三个分量的值分别为:255,0,0。

    像素点

       像素点是最小的图像单元,一张图片由好多的像素点构成,下图是一张美女的大白腿的图片。

    图像处理的灰度化和二值化

     

    查看这张图片的信息,尺寸是800 * 800 的,宽度是800像素,高度是800像素。也就是说这张图片是由一个800 * 800的像素点矩阵构成的(不理解矩阵是什么意思的话,可以把矩阵理解为C语言中的二维数组),这个矩阵是800行,800列,像素是图像的最小单元,这张图片的宽度是800个像素点的长度,高度是800个像素点的长度,共有800 * 800 = 640000个像素点。

    图像处理的灰度化和二值化

     

    因为一个像素点的颜色是由RGB三个值来表现的,所以一个像素点矩阵对应三个颜色向量矩阵,分别是R矩阵,G矩阵,B矩阵,它们也都是800 *800大小的矩阵。下面展示这张美女图片的一部分颜色矩阵数据:

     

    这个是R矩阵中的一部分
    图像处理的灰度化和二值化

     

    这个是G矩阵中的一部分
    图像处理的灰度化和二值化

     

    这个是B矩阵中的一部分

    图像处理的灰度化和二值化

    比如每个矩阵的第一行第一列的值分别为:R:240,G:223,B:204,所以这个像素点的颜色就是(240,223,204),三个矩阵的值不一定一 一对应,这样做只是为了便于读者理解。

     

    图像的灰度化

         在理解了一张图片是由一个像素点矩阵构成之后,我们就知道我们对图像的处理就是对这个像素点矩阵的操作,想要改变某个像素点的颜色,我们只要在这个像素点矩阵中找到这个像素点的位置,比如第x行,第y列,所以这个像素点在这个像素点矩阵中的位置就可以表示成(x,y),因为一个像素点的颜色由红、绿、蓝三个颜色变量表示,所以我们通过给这三个变量赋值,来改变这个像素点的颜色,比如改成红色(255,0,0),可以表示为(x,y,(R=255,G=0,B=0))。

          那么什么叫图片的灰度化呢?其实很简单,就是让像素点矩阵中的每一个像素点都满足下面的关系:R=G=B(就是红色变量的值,绿色变量的值,和蓝色变量的值,这三个值相等,“=”的意思不是程序语言中的赋值,是数学中的相等),此时的这个值叫做灰度值。

     

    灰度处理的方法:

           一般灰度处理经常使用两种方法来进行处理。

       方法1:

              灰度化后的R=(处理前的R + 处理前的G +处理前的B)/ 3

              灰度化后的G=(处理前的R + 处理前的G +处理前的B)/ 3

              灰度化后的B=(处理前的R + 处理前的G +处理前的B)/ 3

     

       美女图片经过方法1进行灰度化后的效果如下:

    图像处理的灰度化和二值化

     

            方法2:

               灰度化后的R =  处理前的R * 0.3+ 处理前的G * 0.59 +处理前的B * 0.11

               灰度化后的G =  处理前的R * 0.3+ 处理前的G * 0.59 +处理前的B * 0.11

               灰度化后的B =  处理前的R * 0.3+ 处理前的G * 0.59 +处理前的B * 0.11

     

         美女图片经过方法2进行灰度化后的效果如下:图像处理的灰度化和二值化

     

    个人觉得第二种方法处理的效果比较好,第一种方法处理后的图片有点模糊。

    图像的二值化

         什么叫图像的二值化?二值化就是让图像的像素点矩阵中的每个像素点的灰度值为0(黑色)或者255(白色),也就是让整个图像呈现只有黑和白的效果。在灰度化的图像中灰度值的范围为0~255,在二值化后的图像中的灰度值范围是0或者255。

          黑色:

                   二值化后的R =  0

                   二值化后的G =  0

                   二值化后的B =  0

          白色:

                   二值化后的R =  255

                   二值化后的G =  255

                   二值化后的B =  255

           那么一个像素点在灰度化之后的灰度值怎么转化为0或者255呢?比如灰度值为100,那么在二值化后到底是0还是255?这就涉及到取一个阀值的问题。

    常用的二值化方法:

          方法1:

              取阀值为127(相当于0~255的中数,(0+255)/2=127),让灰度值小于等于127的变             为0(黑色),灰度值大于127的变为255(白色),这样做的好处是计算量小速度快,但是           缺点也是很明显的,因为这个阀值在不同的图片中均为127,但是不同的图片,他们的颜色          分布差别很大,所以用127做阀值,白菜萝卜一刀切,效果肯定是不好的。

         方法2:

              计算像素点矩阵中的所有像素点的灰度值的平均值avg

              (像素点1灰度值+...+像素点n灰度值)/ n = 像素点平均值avg

             然后让每一个像素点与avg一 一比较,小于等于avg的像素点就为0(黑色),大于avg的 像          素点为255(白色),这样做比方法1好一些。

        方法3:

              使用直方图方法(也叫双峰法)来寻找二值化阀值,直方图是图像的重要特质。直方图方法           认为图像由前景和背景组成,在灰度直方图上,前景和背景都形成高峰,在双峰之间的最低           谷处就是阀值所在。取到阀值之后再一 一比较就可以了。

    下面给出一张美女图片二值化后的效果图:(漂亮的大白腿依稀可见。)

    图像处理的灰度化和二值化
     

          

     

    展开全文
  • 本篇将介绍彩色图像灰度化和二值化的原理,并使用Python来实现对应算法内容。

     

    本篇将介绍彩色图像灰度化和二值化的原理,并使用Python来实现对应算法内容。

    [彩色图像灰度化]

         1.定义

            在上一节中,我们介绍了8位单色灰度图,它使用0-255来表示一个像素,但在实际使用中,我们最常用的还是彩色图像灰度化。对于32位bgra彩色图像,或者24位rgb/bgr彩色图像,一个像素由红绿蓝三原色混合而成,这也就是绘画中的调色过程,如何调制灰色?其实很简单,只要红绿蓝以相同程度进行混合,那么结果就呈现出灰色。基于这个原理,我们可以给出彩色图像灰度化的本质:R=G=B,即红绿蓝三通道的像素值相等,此时,彩色图就表现为灰度图,而这个过程,就叫做彩色图像的灰度化。

            如图Fig.1所示,左侧位32bgra彩色图,右侧为对应的灰度图,该灰度图算法来自Photoshop“去色”命令。

                                                                   (a)32位彩色图                                  (b)32位灰度图

                                                                                     Fig.1 彩色图像灰度化示例

         2.算法

            彩色图像灰度化的算法公式一般常用的有三种:明度公式,视觉公式和Photoshop去色公式。

            ①明度公式

            Gray(i,j)=[R(i,j)+G(i,j)+B(i,j)]/3

             R(i,j)=G(i,j)=B(i,j)=Gray(i,j)

            明度公式,实际上就是取一个像素的红绿蓝三通道均值,将均值作为该像素的灰度值,以此实现灰度化效果。我们用Python语言实现,代码如下:

    ///

    import numpy as np
    import  matplotlib.pyplot as plt
    import matplotlib.image as img
    
    #明度法图像灰度化
    def imgGray_Lum(im):
        """
        image gray
        im: source image
        Return gray image.
        """
        #imgarray = np.array(im)
        imgarray = np.array(im, dtype=np.float32)#以浮点型读取图像数据
        rows = im.shape[0]
        cols = im.shape[1]
        for i in range(rows):
            for j in range(cols):
                imgarray[i, j, :] = np.clip((imgarray[i, j, 0] + imgarray[i, j, 1] + imgarray[i, j, 2]) * 0.3333,0.0,255.0)
        return imgarray.astype(np.uint8)#保存为uint8类型图像
    
    im = img.imread("test.jpg")#图像读取
    im = imgGray_Lum(im)
    plt.imshow(im)#图像显示
    img.imsave('save.jpg',im)

            我们给出明度法彩色图像灰度化的效果测试,如图Fig.2所示。

                                                                                  Fig.2彩色图像灰度化(明度公式)

    ②视觉公式

            Gray(i,j)=0.299R(i,j)+0.587G(i,j)+0.114B(i,j)

            R(i,j)=G(i,j)=B(i,j)=Gray(i,j)

            由于人眼对于颜色的感应是不同的,人眼对绿色的敏感最高,对蓝色敏感最低,因此,上述公式是通过对像素RGB三分量进行加权平均,得到一种较合理的灰度图像,该公式也是最经典的灰度化公式。

            我们用Python语言实现,代码如下:

    /

    import numpy as np
    import  matplotlib.pyplot as plt
    import matplotlib.image as img
     
    #视觉法图像灰度化
    def imgGray_Version(im):
        """
        image gray
        im: source image
        Return gray image.
        """
        imgarray = np.array(im, dtype = np.float32)
        rows = im.shape[0]
        cols = im.shape[1]
        for i in range(rows):
            for j in range(cols):
                imgarray[i, j, :] = (imgarray[i, j, 0] * 0.299 + imgarray[i, j, 1] * 0.587 + imgarray[i, j, 2] * 0.114)
        return imgarray.astype(np.uint8)
    
    im = img.imread("test.jpg")#图像读取
    im = imgGray_Version(im)
    plt.imshow(im)#图像显示
    img.imsave('save.jpg',im)

     

             我们给出视觉颜色法彩色图像灰度化的效果测试,如图Fig.3所示。

                                                                             Fig.3 彩色图像灰度化(视觉颜色公式)

            ③Photoshop去色公式

            Gray(i,j)=[max(R(i,j),G(i,j),B(i,j))+min(R(i,j)+G(i,j)+B(i,j))]/2

            R(i,j)=G(i,j)=B(i,j)=Gray(i,j)

            Photoshop中的去色公式,是一种考虑了图像对比度信息的灰度化公式,可以更好的突出颜色反差,在一些颜色较为接近的图像中表现会比较明显。它的算法比较简单,求取每个像素RGB三通道值的最大值和最小值,然后计算两者的均值,将均值作为灰度化结果即可。我们用Python语言来实现,代码如下:

    ///

    import numpy as np
    import  matplotlib.pyplot as plt
    import matplotlib.image as img
     
    #Photoshop法图像灰度化
    def imgGray_PS(im):
        """
        image gray
        im: source image
        Return gray image.
        """
        imgarray = np.array(im, dtype = np.float32)
        rows = im.shape[0]
        cols = im.shape[1]
        for i in range(rows):
            for j in range(cols):
                maxValue = np.maximum(imgarray[i, j, 0], np.maximum(imgarray[i, j, 1],imgarray[i, j, 2]))
                minValue = np.minimum(imgarray[i, j, 0], np.minimum(imgarray[i, j, 1],imgarray[i, j, 2]))
                imgarray[i, j, :] = (maxValue+ minValue) * 0.5
        return imgarray.astype(np.uint8)
    
    im = img.imread("test.jpg")#图像读取
    im = imgGray_PS(im)
    plt.imshow(im)#图像显示
    img.imsave('save.jpg',im)

     

     我们给出Photoshop去色法彩色图像灰度化的效果测试,如图Fig.4所示。

                                                                      Fig.4 彩色图像灰度化(Photoshop去色法)

            上述三种是常用的彩色图像灰度化算法,作为初学者,我们要透过现象看本质,抓住灰度化的本质,那就是:RGB三通道颜色值相同。

            灰度化算法并非唯一,大家可以根据自己的需求设计自己的灰度化算法,如此才能举一反三,学以致用。

    [彩色图像阈二值化]

            作为本小节的第二个内容,彩色图像二值化实际上就是将一副彩色图,转换为只有两种颜色的图像,我们通常说的黑白阈值化只是其中的一个特例,或者说,黑白二值化是狭义的二值化理解,任意两种颜色二值化则是更为宽泛的理解。如图Fig.5所示,这些都叫作二值化。

                                                                                   Fig.5 彩色图像二值化示例

            我们以灰度图像二值化为例,算法公式如下:

         

            其中,C1和C2分别表示两种颜色值,如果为黑白二值化,则C1和C2表示黑白两种颜色,Threshold表示阈值,范围[0,255],根据阈值将像素划分为C1和C2两类。

            我们用Python语言来实现灰度图像二值化算法,代码如下:

    import numpy as np
    import  matplotlib.pyplot as plt
    import matplotlib.image as img
    
    #image binary threshold process
    def imgBinaryThreshold(img, threshold=128):
        """
        image binary threshold
        im: source image
        threshold:Threshold from 0 to 255
        Return gray image.
        """
        imgarray = np.array(im, dtype = np.uint8)
        rows = im.shape[0]
        cols = im.shape[1]
        for i in range(rows):
            for j in range(cols):
                gray = (imgarray[i, j, 0] * 0.299 + imgarray[i, j, 1] * 0.587 + imgarray[i, j, 2] * 0.114)
                if(gray < threshold):
                    imgarray[i, j, :] = 0
                else:
                    imgarray[i, j, :] = 255
        return imgarray.astype(np.uint8)
    
    
    im = img.imread("test.jpg")#图像读取
    im = imgBinaryThreshold(im)
    plt.imshow(im)#图像显示
    img.imsave('save.jpg',im)

             我们给出彩色图像二值化的效果测试,如图Fig.6所示。

                                                            Fig.6 彩色图像二值化(黑白二值,阈值Threshold=128)

            上述内容就是彩色图像二值化算法,实际上,无论灰度化还是彩色化都并非这么简单,但是作为初学者或者入门者,我们只有掌握了这些最基础的内容,才能去钻研更高深的理论,不积跬步无以至千里就是这个道理。

    [知识扩展]

            灰度化和二值化都是数字图像处理中很重要的组成部分,灰度化中比较热门的是对比度保留的彩色图像去色算法,研究在特殊图像颜色下的灰度化,如图Fig.7所示,一般的灰度化算法处理之后,图像原有的信息已经无法辨识,而对比度保留的灰度化算法处理结果依然可以清晰保留这些信息。

                      (a)原图                              (b)Photoshop灰度化                      (c)Photoshop去色                      (d)对比度保留法

                                                                                  Fig.7 对比度保留法灰度化示例

            Fig.5(d)所示方法的相关论文如下:

            Color2Gray: Salience-Preserving Color Removal  

            Contrast Preserving Decolorization 

            Real-time Contrast Preserving Decolorization

            二值化在图像分割中非常常见,二值化的研究难点是如何自适应设置阈值Threshold来将图像二值化处理,常简的一些自动二值化算法有:Ostu阈值化,P分位阈值化,统计阈值化,最大类间方差二值化等等。

     

     

     

     

     

     

    展开全文
  • 尝试通过灰度化和二值化,将车辆的轮廓从道路中分离出来,至少道路和车辆的色块没有连通。实际上,没有达到预定的目标,在处理图像的过程中,仔细观察每一个算法处理的细节非常重要 代码 #include "cv.h" #include ...
  • **灰度化和二值化的区别**

    千次阅读 2018-12-27 14:27:57
    灰度化和二值化的区别 灰度化: 将彩色图像转化为灰度图像的过程称为图像灰度化。灰度是指只含亮度信息,不含色彩信息的图像。黑白照片就是灰度图,特点是亮度由暗到明,变化是连续的。灰度图像的描述与彩色图像...
  • 图像灰度化和二值化

    2021-03-03 21:45:03
    图像灰度化: 灰度图像上每个像素的颜色又称为灰度,指黑白图像中点的颜色深度,范围一般从0到255,白色为255,黑色为0。所谓灰度是指色彩的浓淡程度,灰度直方图是指一幅数字图像中,对应每一个灰度统计出...
  • c#图像处理 图像预处理 灰度化 二值化 提取像素法 内存法 指针法 灰度化方法:最小值 最大值 加权平均法 二值化方法: 固定值 平均值 Bernsen算法
  • 源:图像处理的灰度化和二值化 灰度处理的方法: 一般灰度处理经常使用两种方法来进行处理。 方法1: 灰度化后的R=(处理前的R + 处理前的G +处理前的B)/ 3 灰度化后的G=(处理前的R + 处理前的G +处理前的B...
  • 本篇主要讲述32位彩色图像的灰度化和二值化内容,通过简单的C语言实现,来帮助初学者一学即会,融会贯通。
  • C语言实现的图像灰度化二值化源代码,不依赖任何第三方库,不使用OPENCV,纯C实现!方便初学者一学即会!
  • 2. 灰度化和二值化算法参考自 https://www.cnblogs.com/rushoooooo/articles/2366154.html 3. 前置知识点: js, canvas 效果概览 完整代码 &lt;!DOCTYPE HTML&gt; &lt;html&gt; &...
  • bmp图片灰度化和二值化

    千次阅读 2020-03-12 20:58:30
    C语言去除bmp图片的背景一、前言二、灰度化头文件C文件三、二值化 一、前言 图像处理中,大部分的处理方法都需要事先把彩色图转换成灰度图才能进行相关的计算、识别。 彩色图转换灰度图的原理如下: 我们知道彩色...
  • 在vs2005上用vc开发的将24真彩色的BMP图片灰度化和二值化,以便于识别表盘指针 自己封装的CDib类,但中值过率有点问题
  • Java基于opencv实现图像数字识别(三)—灰度化和二值化 一、灰度化 灰度化:在RGB模型中,如果R=G=B时,则彩色表示灰度颜色,其中R=G=B的值叫灰度值;因此,灰度图像每个像素点只需一个字节存放灰度值(又称强度值、...
  • opencv图像处理初步(一):灰度化和二值化

    万次阅读 多人点赞 2018-08-07 16:36:54
    一、图像二值化基本原理: 对灰度图像进行处理,设定阈值,在阈值中的像素值将变为1(白色部分),阈值为的将变为0(黑色部分)。 二、图像二值化处理步骤: (1)先对彩色图像进行灰度化 //img为原图,imgGray...
  • 首先我们还是得了解一下定义(搬运工): 灰度化:在RGB模型中,如果R=G=B时,则彩色表示一种...二值化:图像的二值化,就是将图像上的像素点的灰度值设置为0或255,也就是将整个图像呈现出明显的只有黑白的视觉效
  • 用最简单的办法实现彩色图像灰度化和二值化: 首先采用skimage库(skimage库现在在scikit_image库中)实现: from skimage.color import rgb2gray import numpy as np import matplotlib.pyplot as plt plt.subplot...
  • Matlab实现图像的灰度化和二值化

    千次阅读 2019-01-15 23:50:25
    %导入本地的图像(注意路径) InitPicture=imread(‘C:\Users\ASUS\Desktop\car_1.jpg’); %显示原始图像 imshow(InitPicture); ...%使用最大类间方差法找到二值化的阈值 ThresholdValue= g...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,712
精华内容 684
关键字:

灰度化和二值化