精华内容
下载资源
问答
  • im2uint8 im2double

    2015-01-07 15:35:49
    double函数只是将读入图像的uint8数据转换为double类型,一般不使用,常用的是im2double函数,将uint8图像转为double类型,范围为0-1,如果是255的图像...A = im2uint8(mat2gray(result)) 这样就将result矩阵转化为ui
    double函数只是将读入图像的uint8数据转换为double类型,一般不使用,常用的是im2double函数,将uint8图像转为double类型,范围为0-1,如果是255的图像,那么255转为1,0还是0,中间的做相应改变。

    mat2gray是将最终获得的矩阵转化为灰度图像。常用的为
    A = im2uint8(mat2gray(result))
    这样就将result矩阵转化为uint8类型的图像。
    展开全文
  • 原 matlab图像类型转换以及uint8、double、im2double、im2uint8和mat2gray等说明 置顶 2016年11月23日...

    matlab图像类型转换以及uint8、double、im2double、im2uint8和mat2gray等说明

          版权声明:本文为博主原创文章,未经博主允许不得转载。          https://blog.csdn.net/FX677588/article/details/53301740        </div>
            <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/ck_htmledit_views-f57960eb32.css">
                              <div id="content_views" class="markdown_views">
            <!-- flowchart 箭头图标 勿删 -->
            <svg xmlns="http://www.w3.org/2000/svg" style="display: none;">
              <path stroke-linecap="round" d="M5,0 0,2.5 5,5z" id="raphael-marker-block" style="-webkit-tap-highlight-color: rgba(0, 0, 0, 0);"></path>
            </svg>
            <h2 id="1-matlab图像保存说明"><a name="t0"></a><strong>1. matlab图像保存说明</strong></h2>
    

      matlab中读取图片后保存的数据是uint8类型(8位无符号整数,即1个字节),以此方式存储的图像称作8位图像,好处相比较默认matlab数据类型双精度浮点double(64位,8个字节),自然可以节省很大一部分存储空间。
      详细来说imread把灰度图像存入一个8位矩阵,当为RGB图像时,就存入8位RGB矩阵中。例如,彩色图像像素大小是400*300( 高 * 宽 ),则保存的数据矩阵为400*300*3,其中每个颜色通道值是处于0~255之间。
      但是虽然matlab中读入图像的数据类型是uint8,而在图像矩阵运算的时候,使用的数据类型却是double类型。一是为了保证精度,二是因为如果不转换,在对uint8进行加减时会产生溢出,可能提示的错误为: 

    Function ‘*’ is not defined for values of class ‘uint8’

      1个字节无符号整型最大只能存储数据为255,对图片的操作所以很容易溢出。

    2. matlab图像类型转换

      matlab读入图像的数据是uint8,而matlab中数值一般采用double型(64位)存储和运算。所以要先将图像转为double格式的才能运算,区别如下:

    img = imread('./1.jpg'); % 读入是unit8型(0~255)数据
    I1  = im2double(img);    % 把图像转换成double精度类型(0~1)
    I2  = double(img)/255;   % uint8转换成double,作用同im2double
    • 1
    • 2
    • 3

      这里补充说明一下,im2double( )和double( )的区别。double( img)就是简单的数据类型转换,将无符号整型转换为双精度浮点型double,但是数据大小没有变化,原本数据是0~255之间,转化后还是0~255。例如原来是255,那么转换后为255.0,小数位0个数是由double数据长度决定,实际数据大小还是255,只不过这个255已经是double类型空间存储了,再增加不会发生溢出情况。而im2double(img)则不仅仅是将uint8转换到double类型,而且把数据大小从0~255映射到0~1区间。
      另外需要补充说明下面这种情况:

    img = imread('./1.jpg');
    I1  = double(img);
    I2  = im2double(I2); % I2数据依然是0~255,并不是0~1,即I1=I2
    • 1
    • 2
    • 3

      因为I1已经是double类型,imdouble不会对double类型数据0~255映射到区间0~1,所以上面im2double操作没有任何作用,I1和I2相等。
      总结如下:函数im2double将输入转换成double类型。如果输入是uint8、unit16 或者是二值的logical类型,则函数im2double 将其值归一化到0~1之间,当然就是double类型的了。如果输入本身就是double类型,输出还是double类型,并不进行映射。
      如果已经是double类型的数据需要映射,则进行下面操作即可:  

    I2 = I1/255;
    • 1

    3. matlab图像显示imshow类型问题

      在matlab处理完数据好,我们希望显示或者imwrite写入图片时候,需要注意。如果直接对double之间的数据矩阵I运行imshow(I),我们会发现有时候显示的是一个白色的图像。
      这是因为imshow()显示图像时对double型是认为在0~1范围内,即大于1时都是显示为白色,而imshow显示uint8型时是0~255范围。所以对double类型的图像显示的时候,要么归一化到0~1之间,要么将double类型的0~255数据转为uint8类型。解决方法如下:

    imshow(I/255);    % 将图像矩阵转化到0-1之间
    imshow(I,[]);     % 自动调整数据的范围以便于显示
    inshow(uint8(I)); % 转成uint8
    • 1
    • 2
    • 3

    4. uint和double数据转换的深入说明

      double和uint8、uint16之间数据转换有下面的函数:

    im2double(); % 将图像数组转换成double精度类型
    im2uint8();  % 将图像数组转换成unit8类型 
    im2uint16(); % 将图像数组转换成unit16类型
    • 1
    • 2
    • 3

      当然,当图像数据是double类型的0~1之间,下面两者操作是等价的:

    I1=im2uint8(I); 
    I2=uint8(round(I*255)); 
    • 1
    • 2

      但是matlab默认double类型图片数据是位于0~1之间的,而uint8是位于0~255。所以如果矩阵数据图像是double类型(0~1之间)可直接im2uint8,这样不仅完成数据类型转换,而且将0~1之间映射为了0~255之间的数据。
      但是如果图像矩阵数据是double类型的0~255,直接im2uint8转换的话,matlab会将大于1的数据都转换为255,0~1之间的数据才会映射到0~255之间整型的数据。例如下面程序:

    img64 = [1,2,3,4];
    I8    = im2uint8(img64); % I8结果为[255 255 255 255]
    • 1
    • 2

    5. mat2gray()和im2double()区别

      这两个如果都是对uint8数据操作,区别就在于前者是归一化操作,归一化后也在0~1之间,自然结果也是double类型,后者是将数据从0~255映射到0~1。例如:

    I  = uint8([1,1,2,3]);
    I1 = mat2gray(I);  % 归一化,I1结果是double型[0,0,0.5,1]
    I2 = im2double(I); % 映射化,I2结果是double型[0.0039,0.0039,0.0078,0.0118]
    • 1
    • 2
    • 3

      可以看出,虽然两者都是一种归一化,im2double只不过最大值永远是常数255,最小值永远是0,如下:

    I0.0255.00.0I−0.0255.0−0.0

      另外补充一个函数,mat2str()是将数型转换为字符串类型,一般在批量处理图片,给保存图片格式的名称中有作用,这样就不需要格式化sprintf操作了,非常方便。


    个人学习记录,由于能力和时间有限,如果有错误望读者纠正,谢谢!

    转载请注明出处:https://blog.csdn.net/fx677588/article/details/53301740

    展开全文
  • im2uint8函数分析

    2015-06-29 15:53:00
    本次分析的函数为im2uint8,这个函数在图像处理中要用到,主要把图像数据类转换到uint8 uint8函数有效的输入的图像数据类为:logical,uint8,uint16,double,single和int16 如果输入类型为logical,则输入数据...

    环境:Win7 64位 + Matlab R2010a

    本次分析的函数为im2uint8,这个函数在图像处理中要用到,主要把图像数据类转换到uint8

    uint8函数有效的输入的图像数据类为:logical,uint8,uint16,double,single和int16

    • 如果输入类型为logical,则输入数据为1时转换为255,数据为0还是0。
    • 如果输入类型为uint8,则输入数据保持不变。
    • 如果输入类型为uint16,则输入数据除以255,然后四舍五入。
    • 如果输入数据为double,则输入数据乘以255,小于0的数设置为0,大于255的数设置为255,其他的数四舍五入。
    • 如果输入数据为single,处理方式和double一样。
    • 如果输入数据为int16,处理暂且没弄清楚。

     

    上面输出的结果根据Matlab提供的M文件进行分析,M文件如下

    function u = im2uint8(varargin)
    %IM2UINT8 Convert image to 8-bit unsigned integers.
    %   IM2UINT8 takes an image as input, and returns an image of class uint8.  If
    %   the input image is of class uint8, the output image is identical to it.  If
    %   the input image is not uint8, IM2UINT8 returns the equivalent image of class
    %   uint8, rescaling or offsetting the data as necessary.
    %
    %   I2 = IM2UINT8(I1) converts the intensity image I1 to uint8, rescaling the
    %   data if necessary.
    %
    %   RGB2 = IM2UINT8(RGB1) converts the truecolor image RGB1 to uint8, rescaling
    %   the data if necessary.
    %
    %   I = IM2UINT8(BW) converts the binary image BW to a uint8 intensity image,
    %   changing one-valued elements to 255.
    %
    %   X2 = IM2UINT8(X1,'indexed') converts the indexed image X1 to uint8,
    %   offsetting the data if necessary. Note that it is not always possible to
    %   convert an indexed image to uint8. If X1 is double, then the maximum value
    %   of X1 must be 256 or less.  If X1 is uint16, the maximum value of X1 must be
    %   255 or less.
    %
    %   Class Support
    %   -------------
    %   Intensity and truecolor images can be uint8, uint16, double, logical,
    %   single, or int16. Indexed images can be uint8, uint16, double or
    %   logical. Binary input images must be logical. The output image is uint8.
    %
    %   Example
    %   -------
    %       I1 = reshape(uint16(linspace(0,65535,25)),[5 5])
    %       I2 = im2uint8(I1)
    %
    %   See also IM2DOUBLE, IM2INT16, IM2SINGLE, IM2UINT16, UINT8.
    
    %   Copyright 1993-2004 The MathWorks, Inc.
    %   $Revision: 1.20.4.5 $  $Date: 2005/11/15 00:58:23 $
    
    iptchecknargin(1,2,nargin,mfilename);
    
    img = varargin{1};
    iptcheckinput(img,{'double','logical','uint8','uint16','single','int16'}, ...
                  {'nonsparse'},mfilename,'Image',1);
    
    if nargin == 2
      typestr = varargin{2};
      iptcheckstrs(typestr,{'indexed'},mfilename,'type',2);
    end
    
    % 如果图像类型为uint8,则不改变
    if isa(img, 'uint8')
        u = img; 
        
    % 如果图像类型为logical(二值),则将1转为255和0仍然为0
    elseif isa(img, 'logical')
        u=uint8(img);
        u(img)=255;
    
    else %double, single, uint16, or int16
      if nargin == 1        %输入参数个数为1
        if isa(img, 'int16')    %如果图像类型为int16,则将其转为int16--这是因为grayto8函数不支持int16
          img = int16touint16(img);
        end
      
        % intensity image; call MEX-file
        u = grayto8(img);
      
      else        %输入参数个数为2
        if isa(img, 'int16')
          eid = sprintf('Images:%s:invalidIndexedImage',mfilename);
          msg1 = 'An indexed image can be uint8, uint16, double, single, or ';
          msg2 = 'logical.';
          error(eid,'%s %s',msg1, msg2);
        
        elseif isa(img, 'uint16')
          if (max(img(:)) > 255)
            msg = 'Too many colors for 8-bit integer storage.';
            eid = sprintf('Images:%s:tooManyColorsFor8bitStorage',mfilename);
            error(eid,msg);
          else
            u = uint8(img);
          end
        
        else %double or single   值范围1-256
          if max(img(:)) >= 257 
            msg = 'Too many colors for 8-bit integer storage.';
            eid = sprintf('Images:%s:tooManyColorsFor8bitStorage',mfilename);
            error(eid,msg);
          elseif min(img(:)) < 1
            msg = 'Invalid indexed image: an index was less than 1.';
            eid = sprintf('Images:%s:invalidIndexedImage',mfilename);
            error(eid,msg);
          else
            u = uint8(img-1);
          end
        end
      end
    end

     

    这其中有个grayto8函数,这个函数在MEX文件中,具体源代码google找了一份,注释了一下

    /*
     * GRAYTO8 MEX-file
     *
     * B = GRAYTO8(A) converts the double array A to uint8 by scaling A by 255
     * and then rounding.  NaN's in A are converted to 0.  Values in A greater 
     * than 1.0 are converted to 255; values less than 0.0 are converted to 0.
     *
     * B = GRAYTO8(A) converts the uint16 array A by scaling the elements of A
     * 255/65535, rounding, and then casting to uint8.
     *
     * Copyright 1993-2007 The MathWorks, Inc.
     *
     */
    
    #include "mex.h"
    #include "math.h"
    #include "mwsize.h"
    
    // double类型转换
    void ConvertFromDouble(double *pr, uint8_T *qr, mwSize numElements) {
        mwSize k;
        double val;
    
        for (k = 0; k < numElements; k++) {
            val = *pr++;
            if (mxIsNaN(val)) {
                *qr++ = 0;
            }
            else {
                val = val * 255.0 + 0.5;    // 数据加0.5是为了四舍五入需要 例如 uint8(245.1+0.5)=245 和 uint8(245.6+0.5)=246
                if (val > 255.0) val = 255.0;
                if (val < 0.0)   val = 0.0;
                *qr++ = (uint8_T) val;
            }
        }
    }
    
    // single类型转换(处理方式和double类型一样)
    void ConvertFromSingle(float *pr, uint8_T *qr, mwSize numElements) {
        mwSize k;
        float val;
    
        for (k = 0; k < numElements; k++) {
            val = *pr++;
            if (mxIsNaN(val))
                *qr++ = 0;
            else {
                val = val * 255.0f + 0.5f;
                if (val > 255.0) val = 255.0;
                if (val < 0.0)   val = 0.0;
                *qr++ = (uint8_T) val;
            }
        }
    }
    
    // uint16类型转换
    void ConvertFromUint16(uint16_T *pr, uint8_T *qr, mwSize numElements) {
        mwSize k;
        /* 
         除以257的原因来自于uint16数字映射到uint8
         例如数字x转换到uint8
            y = x*255/65535
            由于257 = 65535/255,则y=x/257
        */
        double factor = 1.0 / 257.0;
    
        for (k = 0; k < numElements; k++)
            *qr++ = (uint8_T) ( (double) (*pr++) * factor + 0.5 );
    }
    
    void ValidateInputs(int nrhs, const mxArray *prhs[]) {
        if (nrhs < 1) {
            mexErrMsgIdAndTxt("Images:grayto8:tooFewInputs",
                              "%s","Too few input arguments.");
        }
        if (nrhs > 1) {
            mexErrMsgIdAndTxt("Images:grayto8:tooManyInputs",
                              "%s","Too many input arguments.");
        }
        if (!mxIsDouble(prhs[0]) && !mxIsUint16(prhs[0]) && !mxIsSingle(prhs[0])) {
            mexErrMsgIdAndTxt("Images:grayto8:invalidType",
                              "%s","Input must be double, single, or uint16.");
        }
        if (mxIsComplex(prhs[0])) {
            mexWarnMsgIdAndTxt("Images:grayto8:ignoringImaginaryPartOfInput",
                               "%s","Ignoring imaginary part of input.");
        }
    }
    
    
    void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
        uint8_T *qr;
    
        (void) nlhs;  /* unused parameter */
    
        ValidateInputs(nrhs, prhs);
    
        plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[0]),
                                       mxGetDimensions(prhs[0]), 
                                       mxUINT8_CLASS, mxREAL);
        qr = (uint8_T *) mxGetData(plhs[0]);
    
        if (mxIsDouble(prhs[0]))
            ConvertFromDouble((double *) mxGetData(prhs[0]), qr, mxGetNumberOfElements(prhs[0]));
    
        else if (mxIsUint16(prhs[0]))
            ConvertFromUint16((uint16_T *) mxGetData(prhs[0]), qr, mxGetNumberOfElements(prhs[0]));
    
        else
            ConvertFromSingle((float *) mxGetData(prhs[0]), qr, mxGetNumberOfElements(prhs[0]));
    
    }

     

    转载于:https://www.cnblogs.com/cpointer/p/4606983.html

    展开全文
  •  matlab中读取图片后保存的数据是uint8类型(8位无符号整数,即1个字节),以此方式存储的图像称作8位图像,好处相比较默认matlab数据类型双精度浮点double(64位,8个字节),自然可以节省很大一部分存储空间。...

    【转载】
    原文传送门:https://blog.csdn.net/fx677588/article/details/53301740

    1. matlab图像保存说明

    matlab中读取图片后保存的数据是uint8类型(8位无符号整数,即1个字节),以此方式存储的图像称作8位图像,好处相比较默认matlab数据类型双精度浮点double(64位,8个字节),自然可以节省很大一部分存储空间。
      详细来说imread把灰度图像存入一个8位矩阵,当为RGB图像时,就存入8位RGB矩阵中。例如,彩色图像像素大小是400300( 高 * 宽 ),则保存的数据矩阵为400300*3,其中每个颜色通道值是处于0~255之间。
      但是虽然matlab中读入图像的数据类型是uint8,而在图像矩阵运算的时候,使用的数据类型却是double类型。一是为了保证精度,二是因为如果不转换,在对uint8进行加减时会产生溢出,可能提示的错误为:

    Function ‘*’ is not defined for values of class ‘uint8’
    

    1个字节无符号整型最大只能存储数据为255,对图片的操作所以很容易溢出。

    2. matlab图像类型转换

    matlab读入图像的数据是uint8,而matlab中数值一般采用double型(64位)存储和运算。所以要先将图像转为double格式的才能运算,区别如下:

    img = imread('./1.jpg'); % 读入是unit8型(0~255)数据
    I1  = im2double(img);    % 把图像转换成double精度类型(0~1)
    I2  = double(img)/255;   % uint8转换成double,作用同im2double
    

    这里补充说明一下,im2double( )和double( )的区别。double( img)就是简单的数据类型转换,将无符号整型转换为双精度浮点型double,但是数据大小没有变化,原本数据是0到255之间,转化后还是0到255。例如原来是255,那么转换后为255.0,小数位0个数是由double数据长度决定,实际数据大小还是255,只不过这个255已经是double类型空间存储了,再增加不会发生溢出情况。而im2double(img)则不仅仅是将uint8转换到double类型,而且把数据大小从0到255映射到0到1区间。
      另外需要补充说明下面这种情况:

    img = imread('./1.jpg');
    I1  = double(img);
    I2  = im2double(I2); % I2数据依然是0~255,并不是0~1,即I1=I2
    

    因为I1已经是double类型,imdouble不会对double类型数据0到255映射到区间0到1,所以上面im2double操作没有任何作用,I1和I2相等。
      总结如下:函数im2double将输入转换成double类型。如果输入是uint8、unit16 或者是二值的logical类型,则函数im2double 将其值归一化到0~1之间,当然就是double类型的了。如果输入本身就是double类型,输出还是double类型,并不进行映射。
      如果已经是double类型的数据需要映射,则进行下面操作即可:

    I2 = I1/255;
    

    3. matlab图像显示imshow类型问题

    在matlab处理完数据好,我们希望显示或者imwrite写入图片时候,需要注意。如果直接对double之间的数据矩阵I运行imshow(I),我们会发现有时候显示的是一个白色的图像。
      这是因为imshow()显示图像时对double型是认为在0到1范围内,即大于1时都是显示为白色,而imshow显示uint8型时是0到255范围。所以对double类型的图像显示的时候,要么归一化到0到1之间,要么将double类型的0~255数据转为uint8类型。解决方法如下:

    imshow(I/255);    % 将图像矩阵转化到0-1之间
    imshow(I,[]);     % 自动调整数据的范围以便于显示
    inshow(uint8(I)); % 转成uint8
    

    4. uint和double数据转换的深入说明

    double和uint8、uint16之间数据转换有下面的函数:

    im2double(); % 将图像数组转换成double精度类型
    im2uint8();  % 将图像数组转换成unit8类型 
    im2uint16(); % 将图像数组转换成unit16类型
    

    当然,当图像数据是double类型的0~1之间,下面两者操作是等价的:

    I1=im2uint8(I); 
    I2=uint8(round(I*255)); 
    

    但是matlab默认double类型图片数据是位于0到1之间的,而uint8是位于0到255。所以如果矩阵数据图像是double类型(0到1之间)可直接im2uint8,这样不仅完成数据类型转换,而且将0到1之间映射为了0到255之间的数据。
      但是如果图像矩阵数据是double类型的0到255,直接im2uint8转换的话,matlab会将大于1的数据都转换为255,0到1之间的数据才会映射到0~255之间整型的数据。例如下面程序:

    img64 = [1,2,3,4];
    I8    = im2uint8(img64); % I8结果为[255 255 255 255]
    

    个人学习记录,由于能力和时间有限,如果有错误望读者纠正,谢谢!

    展开全文
  • uint8,im2uint8,double,im2double的区别

    千次阅读 2017-03-07 14:54:20
    这四个命令,对应两种“数据格式”:分别是uint8(范围是0~255)还有 double. 四个命令的区别:  1. double(a)是将a转换成double型数据(注意:只是改变数据格式,并不进行“归一化”)  2. im2double(a)是将a转换...
  • 我在Python中使用Z_axis = bytescale(img)完成了这项工作,但这与在MATLAB中使用im2uint8得到的结果不同。在MATLAB中,使用im2uint8转换成uint8后的DICOM图像的最小值和最大值分别为(124,136)。但是在Python中,...
  • uint8与byte可以说是一样的,因为文档中有这样的定义: The Go Programming Language Specification Numeric types uint8 the set of all unsigned 8-bit integers (0 to 255) byte alias for uint8 1 2 3 4 也就是...
  • matlab为图像提供了特殊的数据类型uint8(8位无符号整数),以此方式存储的图像称作8位图像,可以节省存储空间。 imread把灰度图像存入一个8位矩阵,当为RGB图像时,就存入8位RGB矩阵中。 matlab读入图像...
  • matlab读取图片后保存的数据是uint8类型(8位无符号整数,即1个字节),以此方式存储的图像称作8位图像,比double型(64位,8个字节),节省了存储空间。 **imread()**是将灰度图像存入一个8位矩阵;若为RGB图像时,...
  •  matlab中读取图片后保存的数据是uint8类型(8位无符号整数,即1个字节),以此方式存储的图像称作8位图像,好处相比较默认matlab数据类型双精度浮点double(64位,8个字节),自然可以节省很大一部分存储空间。...
  • 今日在用MATLAB放大...上网找答案未果,之后偶然发现类型不同,原来的是`uint8`,后来变成`double`,仰天长叹。一开始郁闷的滑稽—— ![这里写图片描述](https://ooo.0o0.ooo/2017/07/01/59571e28b5e18.png)顺藤摸瓜
  • %%%%%%%%%%%%%%%数据类型%%%%%%%%%%%%%%%%%% %% 类型转换 clear ...a=uint8(a) %类型转换,小数部分四舍五入 A=[1.1,2.1,3.1;4.1,5.1,6.5;7.6,8.7,9.7] A=uint8(A) %对矩阵一样可以 %% im...
  • matlab将uint16转换成uint8的方法

    万次阅读 2019-01-04 10:00:15
    将一个16位(0~65535)的图像Image转换成8位(0~255),有几种方法: (1)uint8(Image) : 将超过255的shuz数值直接设为255 (2)uint8(double(Image)/65535*255):将0-65535...(3)im2uint8(Image) : 同 (2)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 440
精华内容 176
关键字:

im2uint8