im2uint8函数分析

环境：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 = ; k < numElements; k++) {
        val = *pr++;
        if (mxIsNaN(val)) {
            *qr++ = ;
        }
        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 = ; k < numElements; k++) {
        val = *pr++;
        if (mxIsNaN(val))
            *qr++ = ;
        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 = ; k < numElements; k++)
        *qr++ = (uint8_T) ( (double) (*pr++) * factor + 0.5 );
}

void ValidateInputs(int nrhs, const mxArray *prhs[]) {
    if (nrhs < ) {
        mexErrMsgIdAndTxt("Images:grayto8:tooFewInputs",
                          "%s","Too few input arguments.");
    }
    if (nrhs > ) {
        mexErrMsgIdAndTxt("Images:grayto8:tooManyInputs",
                          "%s","Too many input arguments.");
    }
    if (!mxIsDouble(prhs[]) && !mxIsUint16(prhs[]) && !mxIsSingle(prhs[])) {
        mexErrMsgIdAndTxt("Images:grayto8:invalidType",
                          "%s","Input must be double, single, or uint16.");
    }
    if (mxIsComplex(prhs[])) {
        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[] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[]),
                                   mxGetDimensions(prhs[]),
                                   mxUINT8_CLASS, mxREAL);
    qr = (uint8_T *) mxGetData(plhs[]);

    if (mxIsDouble(prhs[]))
        ConvertFromDouble((double *) mxGetData(prhs[]), qr, mxGetNumberOfElements(prhs[]));

    else if (mxIsUint16(prhs[]))
        ConvertFromUint16((uint16_T *) mxGetData(prhs[]), qr, mxGetNumberOfElements(prhs[]));

    else
        ConvertFromSingle((float *) mxGetData(prhs[]), qr, mxGetNumberOfElements(prhs[]));

}