精华内容
下载资源
问答
  • 灰度共生矩阵matlab代码 灰度共生矩阵matlab代码
  • 实验室师兄写的代码,使用灰度共生矩阵计算图像的纹理复杂度,然后可以用来衡量嵌入水印的多少。
  • 很好的灰度共生矩阵特征提取MATLAB代码,实用,得到了灰度共生矩阵各个特征的值。
  • 这是一种联合灰度统计量分析。图像中相对位置的两个灰度级的两个像素点对,其频数值作为矩阵的值。4个方向,步长距离因纹理而异。统计量一般为熵,能量,相关,反差。
  • 灰度共生矩阵纹理特征提取的Matlab实现
  • 通过该Matlab程序可以求取用于描述图像纹理特征的灰度共生矩阵参数(能量、熵、惯性矩、相关性)。可以分别求取0,45°,90°,135°方向上的特征参数,同时可以求出这些特征参数的平均值与标准差。
  • 灰度共生矩阵纹理特征提取代码 matlab实现
  • 灰度共生矩阵GLCM及其matlab实现

    千次阅读 2018-11-12 11:10:16
    灰度共生矩阵GLCM及其matlab实现

    分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow

    也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!

                           

    Prerequisites

    概念

    计算方式

    对于精度要求高且纹理细密的纹理分布,我们取像素间距为d=1)出现的次数,如图所示,共出现九次,在两个方向上即是18次。


    这里写图片描述


    这里写图片描述

    matlab

    matlab相关工具箱函数

    使用灰度共生矩阵(GLCM)描述和提取图像纹理特征,是一个强大且流行的工具,自然matlab工具箱会提供相应的函数——graycomatrix

    给出一个图像矩阵,设置一些参数,得到其灰度共生矩阵,这就是函数的基本用法:

    [glcm, SI] = graycomatrix(I, ...)
      
    • 1

    主要的参数有二个,分别是

    1. NumLevels(灰度级数)

    最终glcm的size是NumLevels*NumLevels

    1. Offset(方向[0, 1; -1, 1; -1, 0; -1, -1]):

    [0, 1]中的1表示的偏移数(offset),当然也可以取2或者更多,如上文所说,对于精度要求高且图像纹理本身即很丰富的图像来说,为了更精细地刻画,我们取偏移量(offset)为1

    我们将原始I转换为SI,对SI计算GLCM,SI中元素的值介于[1, NumLevels]之间。

    I = [     1 1 5 6 8 8;     2 3 5 7 0 2;     0 2 3 5 6 7    ];[glcm, SI] = graycomatrix(I, 'NumLevels', 9, 'G', [])% 'Offset'的default值为`[0, 1]`
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    glcm =     0     0     2     0     0     0     0     0     0     0     1     0     0     0     1     0     0     0     0     0     0     2     0     0     0     0     0     0     0     0     0     0     2     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     2     1     0     0     0     0     0     0     0     0     1     1     1     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     0     1SI =     2     2     6     7     9     9     3     4     6     8     1     3     1     3     4     6     7     8
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    demo

    这里先写一个demo,稍微有点难懂的地方在于灰度共生矩阵的计算方式,然后是一些编程上的循环判断。其他方向的情况还未考虑(在第三和第四层循环的地方可能会略有不同),以及将其封装成一个函数的操作还是留待以后吧:

    clear, clcP = [ 0 1 2 0 1 2    1 2 0 1 2 0   2 0 1 2 0 1   0 1 2 0 1 2   1 2 0 1 2 0   2 0 1 2 0 1];[r, c] = size(P);P_u = unique(P);        % 去重,得到所有的灰度级n = length(P_u);        % 不同灰度级的个数G = zeros(n, n);        % 初始化灰度共生矩阵为全0矩阵,%% 四层循环,最外层的两层循环用来为GLCM的各个位置赋值% 内层的两层循环时遍历原始图像矩阵,累计符合某一对应关系的的情况出现的次数for p = 1:n,    for q = 1:n,        cnt = 0;            % GLCM刻画的是灰度图像像素的统计特性,在matlab中通过次数的统计计算得到        for i = 1:r,            for j = 1:c,                if  (j+1) <= c && ((P(i, j) == p && P(i, j+1) == q) || P(i, j) == q && P(i, j+1) == p),                    cnt = cnt + 1;                end            end        end        G(p, q) = cnt;    endendG   
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    References

    [1] <图像特征提取——灰度共生矩阵(GLCM)>

               

    给我老师的人工智能教程打call!http://blog.csdn.net/jiangjunshow

    这里写图片描述
    展开全文
  • 灰度共生矩阵matlab实现

    万次阅读 2018-01-24 15:11:59
    matlab函数: graycomatrix()...灰度共生矩阵是像素距离和角度的矩阵函数,它通过计算图像中一定距离和一定方向的两点灰度之间的相关性,来反映图像在方向、间隔、变化幅度及快慢上的综合信息。 使用方法: glcm = grayc
    matlab函数: graycomatrix()

    功           能:创建灰度共生矩阵

    Gray-level co-occurrence matrix from an image

    图像的灰度共生矩阵

    灰度共生矩阵是像素距离和角度的矩阵函数,它通过计算图像中一定距离和一定方向的两点灰度之间的相关性,来反映图像在方向、间隔、变化幅度及快慢上的综合信息。

    使用方法:
    glcm = graycomatrix(I)
    glcms = graycomatrix(I,param1,val1,param2,val2,…)
    [glcms,SI] = graycomatrix(…)

    描述:
    glcms = graycomatrix(I) 产生图像I的灰度共生矩阵GLCM。它是通过计算两灰度值 i,j 在图像 I 中水平相邻的次数而得到的 (你也可以通过调整’ Offsets’ 参数来指定其它的像素空间关系),GLCM中的每一个元素(i,j)代表灰度 i 与灰度 j 在图像 I 中水平相邻的次数。

    graycomatrix()先将图像 I 归一化到指定的灰度级,再计算GLCM;这是因为动态地求取图像的GLCM区间代价过高。如果I是一个二值图像,那么灰度共生矩阵就将图像转换到二值灰度级(黑和白)。如果I是一个灰度图像, 那将转换到8灰度级(默认)。灰度的级数决定了GLCM的大小尺寸,假设灰度级为L,则GLCM的尺寸是L x L。你可以通过设定参数“NumLevels”来指定灰度级数目,还可以通过设置“GrayLimits”参数来设置灰度共生矩阵的转换方式。

    下图在一个4x5的图像I中显示了如何求解灰度共生矩阵,以(1,1)点为例,在图像 I 中水平相邻的像素对的灰度值都为1的情况只出现了1次,所以GLCM(1,1)的值是1。,同理,在图像 I 中水平相邻的像素对的灰度值分别为 1和2 的情况出现了2次,所以GLCM(1,2)的值是2。 graycomatrix迭代以上过程,就可以计算出GLCM的所有位置(L^2)的取值。

      

    glcms = graycomatrix(I,param1,val1,param2,val2,…) 返回一个或多个灰度灰度共生矩阵,根据指定的参数对的值。参数可以简写,并且对大小写不敏感。

    参数
    下面按照字母的顺序列写了参数:
         ‘GrayLimits’  是两个元素的向量[low,high],指明了图像 I 中的灰度值如何线性归一化到灰度级别。低于或等于low的灰度值置成1,大于或等于high的灰度值置成NumLevels。如果其设为[],灰度共生矩阵将使用图像I的最小和最大灰度值分别作为GrayLimits的low和high,即[min(I(:) , max(I(:)))]。

         ‘NumLevels’    一个整数,指定灰度级的数目。例如,如果NumLevels为8,意思就是将图像I的灰度映射到1到8之间,它也决定了灰度共生矩阵的大小。默认值是8。

         ‘Offset’   一个p*2的整数矩阵,指定了感兴趣像素对之间的距离和方向。矩阵中的每一行是一个两元素的向量,[row_offset , col_offset],它指定了一对像素之间的关系,或者说是位移。row_offset是感兴趣像素对间隔的行的数目;col_offset是感兴趣像素对间隔的列的数目。offset通常表示一个角度,下面列写的offset的值指定了常见角度。D代表是当前像素与邻居的距离。

    Angle        Offset
      0              [0 D]
     45             [-D D]
     90             [-D 0]
    135            [-D -D]
         下图说明了数组:offset = [0 1; -1 1; -1 0; -1 -1]

     

         ‘Symmetric’  一个布尔型数(逻辑型),指定创建GLCM时像素对中的两像素的顺序是否考虑。例如,当 ‘Symmetric’ 是true时,graycomatrix计算1连接2的次数时,(1,2)和(2,1)这两种数对都计算在内。当’Symmetric’是false时,graycomatrix只是计算(1,2)或(2,1).

    [glcm,SI] = graycomatrix(….) 返回归一化(灰度级的)图像,SI,它被用来计算灰度共生矩阵(GLCM),SI图像的取值范围是[1,NumLevels]。

    支持类型

          I可以是数字型或逻辑型,但必须是二维的,实数的,非稀疏的矩阵。SI是一个double型矩阵,它和I的尺寸相同。glcms是一个‘NumLevels’ x ‘NumLevels’ x P的double型矩阵,P是offsets的数目(即‘Offset’参数值的列数)。
    说明:

          灰度共生矩阵(GLCM)的另一个名字是灰度空间相关矩阵(gray-level spatial dependence matrix)。另一方面,co-occurrence在文献中使用时经常不带连字符,即cooccurrence。

         如果像素对中的一个像素值为NaN,graycomatrix忽略该像素对。

         graycomatrix用NumLevels值替代positive Inf,用1代替negative Inf。

          如果边界像素的邻居落在图像边界的外边,graycomatrix忽略该边界像素。

         当’Symmetric’设置成’true’时,GLCM 是关于对角线对称的,就是Haralick (1973)描述的GLCM。下面句法(1)使用’Symmetric’为’true’时创建了GLCM等于句法(2)和句法(3)使用’Symmetric’为‘false’时产生的GLCM的和。

     graycomatrix(I, 'offset', [0 1], 'Symmetric', true)    (1)
     graycomatrix(I,'offset',  [0,1], 'Symmetric', false)   (2)
     graycomatrix(I,'offset',  [0,-1], 'Symmetric',false)   (3)

     

    示例:

    计算灰度共生矩阵,并且返回缩放后的图像,SI
    I = [ 1 1 5 6 8 8; 2 3 5 7 0 2; 0 2 3 5 6 7];     % 生成图像I矩阵
    [glcm,SI] = graycomatrix(I,’NumLevels’,9,’G’,[])  % 计算灰度共生矩阵(glcm)和归一化图像(SI)

    计算灰度图像的灰度共生矩阵
    I = imread(‘circuit.tif’);     % 读入circuit.tif图像
    glcm = graycomatrix(I,’Offset’,[2 0]);

    参考文献

    Haralick, R.M., K. Shanmugan, and I. Dinstein, “Textural Features for Image Classification”, IEEE Transactions on Systems, Man, and Cybernetics, Vol. SMC-3, 1973, pp. 610-621.

    Haralick, R.M., and L.G. Shapiro. Computer and Robot Vision: Vol. 1, Addison-Wesley, 1992, p. 459.

     


    灰度共生矩阵的特征:

    角二阶矩(Angular Second Moment, ASM)

    也称为 能量
    ASM=sum(p(i,j).^2)    p(i,j)指归一化后的灰度共生矩阵
    角二阶矩是图像灰度分布均匀程度和纹理粗细的一个度量,当图像纹理绞细致、灰度分布均匀时,能量值较大,反之,较小。

    熵(Entropy, ENT)
    ENT=sum(p(i,j)*(-ln(p(i,j)))    
    是描述图像具有的信息量的度量,表明图像的复杂程序,当复杂程序高时,熵值较大,反之则较小。

    反差分矩阵(Inverse Differential Moment, IDM)
    IDM=sum(p(i,j)/(1+(i-j)^2))
    反映了纹理的清晰程度和规则程度,纹理清晰、规律性较强、易于描述的,值较大;杂乱无章的,难于描述的,值较小。

    ************************************************************************************************************************************************************************

      *************************************************************  graycomatrix源程序代码  *****************************************************************************

     ************************************************************************************************************************************************************************

    [plain]  view plain copy print ?


    1. function [GLCMS,SI] = graycomatrix(varargin)  

    2. %GRAYCOMATRIX Create gray-level co-occurrence matrix.  

    3. %   GLCMS = GRAYCOMATRIX(I) analyzes pairs of horizontally adjacent pixels  

    4. %   in a scaled version of I.  If I is a binary image, it is scaled to 2  

    5. %   levels. If I is an intensity image, it is scaled to 8 levels. In this  

    6. %   case, there are 8 x 8 = 64 possible ordered combinations of values for  

    7. %   each pixel pair. GRAYCOMATRIX accumulates the total occurrence of each  

    8. %   such combination, producing a 8-by-8 output array, GLCMS. The row and  

    9. %   column subscripts in GLCMS correspond respectively to the first and  

    10. %   second (scaled) pixel-pair values.  

    11. %  

    12. %   GLCMS = GRAYCOMATRIX(I,PARAM1,VALUE1,PARAM2,VALUE2,…) returns one or  

    13. %   more gray-level co-occurrence matrices, depending on the values of the  

    14. %   optional parameter/value pairs. Parameter names can be abbreviated, and  

    15. %   case does not matter.  

    16. %     

    17. %   Parameters include:  

    18. %    

    19. %   ‘Offset’         A p-by-2 array of offsets specifying the distance   

    20. %                    between the pixel-of-interest and its neighbor. Each   

    21. %                    row in the array is a two-element vector,   

    22. %                    [ROW_OFFSET COL_OFFSET], that specifies the   

    23. %                    relationship, or ‘Offset’, between a pair of pixels.   

    24. %                    ROW_OFFSET is the number of rows between the   

    25. %                    pixel-of-interest and its neighbor.  COL_OFFSET is the  

    26. %                    number of columns between the pixel-of-interest and   

    27. %                    its neighbor. For example, if you want the number of  

    28. %                    occurrences where the pixel of interest is one pixel   

    29. %                    to the left of its neighbor, then   

    30. %                    [ROW_OFFSET COL_OFFSET] is [0 1].  

    31. %    

    32. %                    Because this offset is often expressed as an angle,   

    33. %                    the following table lists the offset values that   

    34. %                    specify common angles, given the pixel distance D.  

    35. %                              

    36. %                    Angle     OFFSET  

    37. %                    —–     ——    

    38. %                    0         [0 D]     

    39. %                    45        [-D D]  

    40. %                    90        [-D 0]  

    41. %                    135       [-D -D]    

    42. %    

    43. %                    ROW_OFFSET and COL_OFFSET must be integers.   

    44. %  

    45. %                    Default: [0 1]  

    46. %              

    47. %   ‘NumLevels’      An integer specifying the number of gray levels to use when  

    48. %                    scaling the grayscale values in I. For example, if  

    49. %                    ‘NumLevels’ is 8, GRAYCOMATRIX scales the values in I so  

    50. %                    they are integers between 1 and 8.  The number of gray levels  

    51. %                    determines the size of the gray-level co-occurrence matrix  

    52. %                    (GLCM).  

    53. %  

    54. %                    ‘NumLevels’ must be an integer. ‘NumLevels’ must be 2 if I  

    55. %                    is logical.  

    56. %    

    57. %                    Default: 8 for numeric  

    58. %                             2 for logical  

    59. %     

    60. %   ‘GrayLimits’     A two-element vector, [LOW HIGH], that specifies how   

    61. %                    the grayscale values in I are linearly scaled into   

    62. %                    gray levels. Grayscale values less than or equal to   

    63. %                    LOW are scaled to 1. Grayscale values greater than or   

    64. %                    equal to HIGH are scaled to HIGH.  If ‘GrayLimits’ is   

    65. %                    set to [], GRAYCOMATRIX uses the minimum and maximum   

    66. %                    grayscale values in I as limits,   

    67. %                    [min(I(:)) max(I(:))].  

    68. %    

    69. %                    Default: the LOW and HIGH values specified by the  

    70. %                    class, e.g., [LOW HIGH] is [0 1] if I is double and  

    71. %                    [-32768 32767] if I is int16.  

    72. %  

    73. %   ‘Symmetric’      A Boolean that creates a GLCM where the ordering of  

    74. %                    values in the pixel pairs is not considered. For  

    75. %                    example, when calculating the number of times the  

    76. %                    value 1 is adjacent to the value 2, GRAYCOMATRIX  

    77. %                    counts both 1,2 and 2,1 pairings, if ‘Symmetric’ is  

    78. %                    set to true. When ‘Symmetric’ is set to false,  

    79. %                    GRAYCOMATRIX only counts 1,2 or 2,1, depending on the  

    80. %                    value of ‘offset’. The GLCM created in this way is  

    81. %                    symmetric across its diagonal, and is equivalent to  

    82. %                    the GLCM described by Haralick (1973).  

    83. %  

    84. %                    The GLCM produced by the following syntax,   

    85. %  

    86. %                    graycomatrix(I, ‘offset’, [0 1], ‘Symmetric’, true)  

    87. %  

    88. %                    is equivalent to the sum of the two GLCMs produced by  

    89. %                    these statements.  

    90. %  

    91. %                    graycomatrix(I, ‘offset’, [0 1], ‘Symmetric’, false)   

    92. %                    graycomatrix(I, ‘offset’, [0 -1], ‘Symmetric’, false)   

    93. %  

    94. %                    Default: false  

    95. %    

    96. %    

    97. %   [GLCMS,SI] = GRAYCOMATRIX(…) returns the scaled image used to  

    98. %   calculate GLCM. The values in SI are between 1 and ‘NumLevels’.  

    99. %  

    100. %   Class Support  

    101. %   ————-               

    102. %   I can be numeric or logical.  I must be 2D, real, and nonsparse. SI is  

    103. %   a double matrix having the same size as I.  GLCMS is an  

    104. %   ‘NumLevels’-by-‘NumLevels’-by-P double array where P is the number of  

    105. %   offsets in OFFSET.  

    106. %    

    107. %   Notes  

    108. %   —–  

    109. %   Another name for a gray-level co-occurrence matrix is a gray-level  

    110. %   spatial dependence matrix.  

    111. %  

    112. %   GRAYCOMATRIX ignores pixels pairs if either of their values is NaN. It  

    113. %   also replaces Inf with the value ‘NumLevels’ and -Inf with the value 1.  

    114. %  

    115. %   GRAYCOMATRIX ignores border pixels, if the corresponding neighbors  

    116. %   defined by ‘Offset’ fall outside the image boundaries.  

    117. %  

    118. %   References  

    119. %   ———-  

    120. %   Haralick, R.M., K. Shanmugan, and I. Dinstein, “Textural Features for  

    121. %   Image Classification”, IEEE Transactions on Systems, Man, and  

    122. %   Cybernetics, Vol. SMC-3, 1973, pp. 610-621.  

    123. %  

    124. %   Haralick, R.M., and L.G. Shapiro. Computer and Robot Vision: Vol. 1,  

    125. %   Addison-Wesley, 1992, p. 459.  

    126. %  

    127. %   Example 1  

    128. %   ———        

    129. %   Calculate the gray-level co-occurrence matrix (GLCM) and return the  

    130. %   scaled version of the image, SI, used by GRAYCOMATRIX to generate the  

    131. %   GLCM.  

    132. %  

    133. %        I = [1 1 5 6 8 8;2 3 5 7 0 2; 0 2 3 5 6 7];  

    134. %       [GLCMS,SI] = graycomatrix(I,’NumLevels’,9,’G’,[])  

    135. %       

    136. %   Example 2  

    137. %   ———    

    138. %   Calculate the gray-level co-occurrence matrix for a grayscale image.  

    139. %    

    140. %       I = imread(‘circuit.tif’);  

    141. %       GLCMS = graycomatrix(I,’Offset’,[2 0])  

    142. %  

    143. %   Example 3  

    144. %   ———  

    145. %   Calculate gray-level co-occurrences matrices for a grayscale image  

    146. %   using four different offsets.  

    147. %    

    148. %       I = imread(‘cell.tif’);  

    149. %       offsets = [0 1;-1 1;-1 0;-1 -1];  

    150. %       [GLCMS,SI] = graycomatrix(I,’Of’,offsets);   

    151. %  

    152. %   Example 4  

    153. %   ———    

    154. %   Calculate the symmetric gray-level co-occurrence matrix (the Haralick  

    155. %   definition) for a grayscale image.  

    156. %    

    157. %       I = imread(‘circuit.tif’);  

    158. %       GLCMS = graycomatrix(I,’Offset’,[2 0],’Symmetric’, true)  

    159. %    

    160. %   See also GRAYCOPROPS.  

    161.     

    162. %   Copyright 1993-2008 The MathWorks, Inc.  

    163. %   Revision.1&nbsp; Revision.1&nbsp;   Date:&nbsp;2008/04/03&nbsp;03:10:53&nbsp; Date:&nbsp;2008/04/03&nbsp;03:10:53&nbsp;   

    164.   

    165. [I, Offset, NL, GL, makeSymmetric] = ParseInputs(varargin{:});  

    166.   

    167. % Scale I so that it contains integers between 1 and NL.  

    168. if GL(2) == GL(1)  

    169.   SI = ones(size(I));  

    170. else  

    171.   slope = (NL-1) / (GL(2) - GL(1));  

    172.   intercept = 1 - (slope*(GL(1)));  

    173.   SI = round(imlincomb(slope,I,intercept,’double’));  

    174. end  

    175.   

    176. % Clip values if user had a value that is outside of the range, e.g.,  

    177. % double image = [0 .5 2;0 1 1]; 2 is outside of [0,1]. The order of the  

    178. % following lines matters in the event that NL = 0.  

    179. SI(SI > NL) = NL;  

    180. SI(SI < 1) = 1;  

    181.   

    182. numOffsets = size(Offset,1);  

    183.   

    184. if NL ~= 0  

    185.   

    186.   % Create vectors of row and column subscripts for every pixel and its  

    187.   % neighbor.  

    188.   s = size(I);  

    189.   [r,c] = meshgrid(1:s(1),1:s(2));  

    190.   r = r(:);  

    191.   c = c(:);  

    192.   

    193.   % Compute GLCMS  

    194.   GLCMS = zeros(NL,NL,numOffsets);  

    195.   for k = 1 : numOffsets  

    196.     GLCMS(:,:,k) = computeGLCM(r,c,Offset(k,:),SI,NL);  

    197.       

    198.     if makeSymmetric   

    199.         % Reflect glcm across the diagonal  

    200.         glcmTranspose = GLCMS(:,:,k).’;  

    201.         GLCMS(:,:,k) = GLCMS(:,:,k) + glcmTranspose;  

    202.     end  

    203.   end  

    204.   

    205. else  

    206.   GLCMS = zeros(0,0,numOffsets);  

    207. end  

    208.   

    209. %—————————————————————————–  

    210. function oneGLCM = computeGLCM(r,c,offset,si,nl)  

    211. % computes GLCM given one Offset  

    212.   

    213. r2 = r + offset(1);  

    214. c2 = c + offset(2);  

    215.   

    216. [nRow nCol] = size(si);  

    217. % Determine locations where subscripts outside the image boundary  

    218. outsideBounds = find(c2 < 1 | c2 > nCol | r2 < 1 | r2 > nRow);  

    219.   

    220. % Create vector containing si(r1,c1)  

    221. v1 = shiftdim(si,1);  

    222. v1 = v1(:);  

    223. v1(outsideBounds) = [];  

    224.   

    225. % Create vector containing si(r2,c2). Not using sub2ind for performance  

    226. % reasons  

    227. r2(outsideBounds) = []; %#ok  

    228. c2(outsideBounds) = []; %#ok  

    229. Index = r2 + (c2 - 1)*nRow;  

    230. v2 = si(Index);  

    231.   

    232. % Remove pixel and its neighbor if their value is NaN.  

    233. bad = isnan(v1) | isnan(v2);  

    234. if any(bad)  

    235.     wid = sprintf(‘Images:%s:scaledImageContainsNan’,mfilename);  

    236.     warning(wid, …  

    237.         ‘GLCM does not count pixel pairs if either of their values is NaN.’);  

    238. end  

    239.   

    240. Ind = [v1 v2];  

    241. Ind(bad,:) = [];  

    242.   

    243. if isempty(Ind)  

    244.     oneGLCM = zeros(nl);  

    245. else  

    246.     % Tabulate the occurrences of pixel pairs having v1 and v2.  

    247.     oneGLCM = accumarray(Ind, 1, [nl nl]);  

    248. end  

    249.   

    250. %—————————————————————————–  

    251. function [I, offset, nl, gl, sym] = ParseInputs(varargin)  

    252.   

    253. iptchecknargin(1,9,nargin,mfilename);  

    254.   

    255. % Check I  

    256. I = varargin{1};  

    257. iptcheckinput(I,{‘logical’,’numeric’},{‘2d’,’real’,’nonsparse’}, …  

    258.               mfilename,’I’,1);  

    259.   

    260. % Assign Defaults  

    261. offset = [0 1];  

    262. if islogical(I)  

    263.   nl = 2;  

    264. else  

    265.   nl = 8;  

    266. end  

    267. gl = getrangefromclass(I);  

    268. sym = false;  

    269.   

    270. % Parse Input Arguments  

    271. if nargin ~= 1  

    272.    

    273.   paramStrings = {‘Offset’,’NumLevels’,’GrayLimits’,’Symmetric’};  

    274.     

    275.   for k = 2:2:nargin  

    276.   

    277.     param = lower(varargin{k});  

    278.     inputStr = iptcheckstrs(param, paramStrings, mfilename, ‘PARAM’, k);  

    279.     idx = k + 1;  %Advance index to the VALUE portion of the input.  

    280.     if idx > nargin  

    281.       eid = sprintf(‘Images:%s:missingParameterValue’, mfilename);  

    282.       error(eid,’Parameter ”%s” must be followed by a value.’, inputStr);          

    283.     end  

    284.       

    285.     switch (inputStr)  

    286.        

    287.      case ‘Offset’  

    288.         

    289.       offset = varargin{idx};  

    290.       iptcheckinput(offset,{‘logical’,’numeric’},…  

    291.                     {‘2d’,’nonempty’,’integer’,’real’},…  

    292.                     mfilename, ‘OFFSET’, idx);  

    293.       if size(offset,2) ~= 2  

    294.         eid = sprintf(‘Images:%s:invalidOffsetSize’,mfilename);  

    295.         error(eid, ‘OFFSET must be an N-by-2 array.’);  

    296.       end  

    297.       offset = double(offset);  

    298.   

    299.      case ‘NumLevels’  

    300.         

    301.       nl = varargin{idx};  

    302.       iptcheckinput(nl,{‘logical’,’numeric’},…  

    303.                     {‘real’,’integer’,’nonnegative’,’nonempty’,’nonsparse’},…  

    304.                     mfilename, ‘NL’, idx);  

    305.       if numel(nl) > 1  

    306.         eid = sprintf(‘Images:%s:invalidNumLevels’,mfilename);  

    307.         error(eid, ‘NL cannot contain more than one element.’);  

    308.       elseif islogical(I) && nl ~= 2  

    309.         eid = sprintf(‘Images:%s:invalidNumLevelsForBinary’,mfilename);  

    310.         error(eid, ‘NL must be two for a binary image.’);  

    311.       end  

    312.       nl = double(nl);        

    313.        

    314.      case ‘GrayLimits’  

    315.         

    316.       gl = varargin{idx};  

    317.       iptcheckinput(gl,{‘logical’,’numeric’},{‘vector’,’real’},…  

    318.                     mfilename, ‘GL’, idx);  

    319.       if isempty(gl)  

    320.         gl = [min(I(:)) max(I(:))];  

    321.       elseif numel(gl) ~= 2  

    322.         eid = sprintf(‘Images:%s:invalidGrayLimitsSize’,mfilename);  

    323.         error(eid, ‘GL must be a two-element vector.’);  

    324.       end  

    325.       gl = double(gl);  

    326.       

    327.       case ‘Symmetric’  

    328.         sym = varargin{idx};  

    329.         iptcheckinput(sym,{‘logical’}, {‘scalar’}, mfilename, ‘Symmetric’, idx);  

    330.           

    331.     end  

    332.   end  

    333. end  




    展开全文
  • glcm matlab代码灰度共生矩阵(GLCM) Matlab代码和PDF实现UiO的Digital Image Analysis类INF9305必需的GLCM功能。
  • 灰度共生矩阵MatLab实现

    千次阅读 2020-10-19 11:01:58
    上周五在复现一篇论文("Visual-Salience-Based Tone Mapping for High Dynamic Range Images")中的算法时涉足到了基于灰度共生矩阵的显著性度量,便顺手给实现了以下。我们将共生关系定义在w*w的窗口内,窗口内的...

    上周五在复现一篇论文("Visual-Salience-Based Tone Mapping for High Dynamic Range Images")中的算法时涉足到了基于灰度共生矩阵的显著性度量,便顺手给实现了以下。我们将共生关系定义在w*w的窗口内,窗口内的不同两个像素p、q为共生关系,其灰度I_pI_q即为共生灰度。论文算法在计算灰度共生矩阵前会先将灰度值量化为K个等级。当共生关系的考察窗口半径为r时,对于每个像素,我们只需要考察它右下方(包含本行和本列)的(r+1)*(r+1)-1个像素。因为站在当前像素p角度去考察左上方像素q等同于从像素q角度去考察右下角像素p,所以没有必要考察另外3个子分区(以当前像素为原点将窗口划为4个分区的话)。

    下面将代码贴出来与大家分享:

    function M=ICH(img,K,r)
    %求灰度共生矩阵程序
    %K为量化等级
    %r为衡量共生性质的邻域半径,灰度m,n在(2r+1,2r+1)的窗口内同时出现过即视为共生
    if ~exist('K','var')
        K=255;
    end
    if ~exist('r','var')
        r=4;
    end
    interval=(max(img(:))-min(img(:)))/(K-0.5);
    Q=floor((img-min(img(:)))/interval)+1;
    rowNum=size(Q,1);
    M=zeros(K,K);
    idxShift=zeros(r+1,r+1); %参考像素相对于当前像素的索引偏移量
    for i=0:r
        for j=0:r
            idxShift(i+1,j+1)=i+j*rowNum;
        end
    end
    idxShift=idxShift(:);
    for p=2:length(idxShift) %idxShift(1)为0,表示当前进行统计的两像素实际为同一像素,跳过
        for i=1:size(Q,1)-r
            for j=1:size(Q,2)-r
                idx=(j-1)*rowNum+i;
                s=idxShift(p);
                M(Q(idx),Q(idx+s))=M(Q(idx),Q(idx+s))+1;
                M(Q(idx+s),Q(idx))=M(Q(idx+s),Q(idx))+1;
            end
        end
    end

    脚本文件:

    img=rgb2gray(imread('onion.png'));
    K=255;
    r=4;
    M=ICH(img,K,r);
    nM=M/sum(M(:)); %归一化
    figure,imshow(10*nM/max(nM(:)));

    r=4的输出结果为:

    r=10的输出结果为:

    可以看出,这种基于灰度共生矩阵的显著性度量计算复杂度是正比于窗口半径(实际是半径加1)的平方的,对于r=4的情况,每个点需要考察24个共生点。而基于最小方向对比度的显著性度量由于利用了积分图优化,每个像素点的计算复杂度是O(1)量级,只需要进行几次加减、乘方和开方运算,从计算复杂度而言更低,所以可以考虑采用基于最小方向对比度的显著性度量来替代基于灰度共生矩阵的显著性度量来减少计算量。当然啦,具体效果还需要实验后才能评价。

    展开全文
  • MATLAB灰度共生矩阵纹理特征提取

    热门讨论 2013-07-17 21:13:46
    MATLAB 灰度共生矩阵 纹理特征提取 粗糙度、对比度、方向度等,源代码
  • 灰度共生矩阵提取图像纹理特征,采用matlab实现,包括模糊c均值实现分类。代码完整,正确可运行。
  • 编写的是一个计算数字图像灰度共生矩阵及典型参数的MATLAB函数。
  • 灰度共生矩阵GLCM的matlab代码实现
  • 灰度共生矩阵介绍,还有matlab函数,个人觉得讲得还是短而精悍的,推荐推荐
  • 灰度共生矩阵_matlab

    2017-05-05 21:20:01
    使用MATLAB计算图像的灰度共生矩阵代码
  • 该程序用于求解数字图像处理的灰度共生矩阵的纹理特征值,如熵、对比度,同质性、能量等。只需要将该m文件放在Matlab的安装目录:toolbox/images/images文件夹里,按照参数设定,直接调用即可。
  • 今天在做一个灰度共生矩阵的程序的时候,看了几篇文章,得到了以下代码,可以实现matlab灰度共生矩阵的提取: clc clear close all %灰度共生矩阵 SI = imread('test file.jpg'); I = [ 1 1 5 6 8 8; 2 3 5 ...

    今天在做一个灰度共生矩阵的程序的时候,看了几篇文章,得到了以下代码,可以实现matlab的灰度共生矩阵的提取:

    clc
    clear
    close all
    %灰度共生矩阵
    SI = imread('test file.jpg');
    I = [ 
        1 1 5 6 8 8; 
        2 3 5 7 0 2; 
        0 2 3 5 6 7
        ];
    [glcm,SI]=graycomatrix(I);
    glcm=graycomatrix(I);
    stat=graycoprops(glcm,'all');
    glcm
    SI
    I
    stat
    
    %代码实现结果
    glcm =
    
         0     0     0     0     0     0     0     2
         0     0     0     0     0     0     0     0
         0     0     0     0     0     0     0     0
         0     0     0     0     0     0     0     0
         0     0     0     0     0     0     0     0
         0     0     0     0     0     0     0     0
         0     0     0     0     0     0     0     0
         1     0     0     0     0     0     0    12
    
    
    SI =
    
         8     8     8     8     8     8
         8     8     8     8     1     8
         1     8     8     8     8     8
    
    
    I =
    
         1     1     5     6     8     8
         2     3     5     7     0     2
         0     2     3     5     6     7
    
    
    stat = 
    
      包含以下字段的 struct:
    
           Contrast: 9.8000
        Correlation: -0.1048
             Energy: 0.6622
        Homogeneity: 0.8250

     

    展开全文
  • 灰度共生矩阵相关资料,包括生成灰度共生矩阵matlab代码,Matlab7工具箱中缺少的graycomatrix.m文件,以及一个通过灰度共生矩阵提取特征的matlab程序(共20多个特征),可以根据他的方法来从灰度共生矩阵中提取你...
  • 我自己实现的灰度共生矩阵提取结肠癌图像特征,并利用计算机辅助诊断的方法SVM分类Matlab代码
  • 利用灰度共生矩阵实现图像纹理特征的提取,从而实现对图像纹理特征的研究
  • 灰度共生矩阵(附python代码

    千次阅读 2020-06-03 16:45:23
    灰度共生矩阵这个陌生的家伙,于是便有此文。 主要参考博客1:http://blog.csdn.net/jialeheyeshu/article/details/51337225 主要参考博客2:http://blog.csdn.net/guanyuqiu/article/details/53117507 主要参考...
  • 194 信息技术 灰度共生矩阵和颜色自相关图矩阵的matlab实现文⊙ 菅小艳(太原师范学院 山西太原) 摘要: 基于内容的图像检索是当今人们研究的热点,本文通过matlab2006 算法实现了灰度共生矩阵和颜色自相关矩阵,并...
  • I = imread('C:\cameraman.tif'); imshow(I) offsets = [0 1; -1 1;-1 0;-1 -1]; [glcms,SI] = graycomatrix(I,'Offset',offsets); imshow(rescale(SI)) ...I = imread('C:\cameraman.tif');...[glcm,SI] = graycomatrix(I
  • 我下了一个用灰度梯度共生矩阵提取纹理特征的源程序,现在我处理图像 比如说matlab自带的一幅图像cions.png下面是源程序:function OUT=GrayGradinet(IN)% 灰度梯度共生矩阵 H%归一化灰度梯度矩阵 H_basic%小梯度...
  • matlab自带函数实现灰度共生矩阵,求取特征值 2018年04月05日 18:56:04 yukunjake 阅读数:794 ...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 220
精华内容 88
关键字:

灰度共生矩阵matlab代码

matlab 订阅