Radiomic Features

This section contains the definitions of the various features that can be extracted using PyRadiomics. They are subdivided into the following classes:

All feature classes, with the exception of shape can be calculated on either the original image and/or a derived image, obtained by applying one of several filters. The shape descriptors are independent of gray value, and are extracted from the label mask. If enabled, they are calculated separately of enabled input image types, and listed in the result as if calculated on the original image.

Most features defined below are in compliance with feature definitions as described by the Imaging Biomarker Standardization Initiative (IBSI), which are available in a separate document by Zwanenburg et al. (2016) [1]. Where features differ, a note has been added specifying the difference.

First Order Features

class radiomics.firstorder.RadiomicsFirstOrder(inputImage, inputMask, **kwargs)[source]

Bases: radiomics.base.RadiomicsFeaturesBase

First-order statistics describe the distribution of voxel intensities within the image region defined by the mask through commonly used and basic metrics.

Let:

  • \(\textbf{X}\) be a set of \(N_p\) voxels included in the ROI
  • \(\textbf{P}(i)\) be the first order histogram with \(N_g\) discrete intensity levels, where \(N_g\) is the number of non-zero bins, equally spaced from 0 with a width defined in the binWidth parameter.
  • \(p(i)\) be the normalized first order histogram and equal to \(\frac{\textbf{P}(i)}{N_p}\)

Following additional settings are possible:

  • voxelArrayShift [0]: Integer, This amount is added to the gray level intensity in features Energy, Total Energy and RMS, this is to prevent negative values. If using CT data, or data normalized with mean 0, consider setting this parameter to a fixed value (e.g. 2000) that ensures non-negative numbers in the image. Bear in mind however, that the larger the value, the larger the volume confounding effect will be.

Note

In the IBSI feature definitions, no correction for negative gray values is implemented. To achieve similar behaviour in PyRadiomics, set voxelArrayShift to 0.

getEnergyFeatureValue()[source]

1. Energy

\[\textit{energy} = \displaystyle\sum^{N_p}_{i=1}{(\textbf{X}(i) + c)^2}\]

Here, \(c\) is optional value, defined by voxelArrayShift, which shifts the intensities to prevent negative values in \(\textbf{X}\). This ensures that voxels with the lowest gray values contribute the least to Energy, instead of voxels with gray level intensity closest to 0.

Energy is a measure of the magnitude of voxel values in an image. A larger values implies a greater sum of the squares of these values.

Note

This feature is volume-confounded, a larger value of \(c\) increases the effect of volume-confounding.

getTotalEnergyFeatureValue()[source]

2. Total Energy

\[\textit{total energy} = V_{voxel}\displaystyle\sum^{N_p}_{i=1}{(\textbf{X}(i) + c)^2}\]

Here, \(c\) is optional value, defined by voxelArrayShift, which shifts the intensities to prevent negative values in \(\textbf{X}\). This ensures that voxels with the lowest gray values contribute the least to Energy, instead of voxels with gray level intensity closest to 0.

Total Energy is the value of Energy feature scaled by the volume of the voxel in cubic mm.

Note

This feature is volume-confounded, a larger value of \(c\) increases the effect of volume-confounding.

Note

Not present in IBSI feature definitions

getEntropyFeatureValue()[source]

3. Entropy

\[\textit{entropy} = -\displaystyle\sum^{N_g}_{i=1}{p(i)\log_2\big(p(i)+\epsilon\big)}\]

Here, \(\epsilon\) is an arbitrarily small positive number (\(\approx 2.2\times10^{-16}\)).

Entropy specifies the uncertainty/randomness in the image values. It measures the average amount of information required to encode the image values.

Note

Defined by IBSI as Intensity Histogram Entropy.

getMinimumFeatureValue()[source]

4. Minimum

\[\textit{minimum} = \min(\textbf{X})\]
get10PercentileFeatureValue()[source]

5. 10th percentile

The 10th percentile of \(\textbf{X}\)

get90PercentileFeatureValue()[source]

6. 90th percentile

The 90th percentile of \(\textbf{X}\)

getMaximumFeatureValue()[source]

7. Maximum

\[\textit{maximum} = \max(\textbf{X})\]

The maximum gray level intensity within the ROI.

getMeanFeatureValue()[source]

8. Mean

\[\textit{mean} = \frac{1}{N_p}\displaystyle\sum^{N_p}_{i=1}{\textbf{X}(i)}\]

The average gray level intensity within the ROI.

getMedianFeatureValue()[source]

9. Median

The median gray level intensity within the ROI.

getInterquartileRangeFeatureValue()[source]

10. Interquartile Range

\[\textit{interquartile range} = \textbf{P}_{75} - \textbf{P}_{25}\]

Here \(\textbf{P}_{25}\) and \(\textbf{P}_{75}\) are the 25th and 75th percentile of the image array, respectively.

getRangeFeatureValue()[source]

11. Range

\[\textit{range} = \max(\textbf{X}) - \min(\textbf{X})\]

The range of gray values in the ROI.

getMeanAbsoluteDeviationFeatureValue()[source]

12. Mean Absolute Deviation (MAD)

\[\textit{MAD} = \frac{1}{N_p}\displaystyle\sum^{N_p}_{i=1}{|\textbf{X}(i)-\bar{X}|}\]

Mean Absolute Deviation is the mean distance of all intensity values from the Mean Value of the image array.

getRobustMeanAbsoluteDeviationFeatureValue()[source]

13. Robust Mean Absolute Deviation (rMAD)

\[\textit{rMAD} = \frac{1}{N_{10-90}}\displaystyle\sum^{N_{10-90}}_{i=1} {|\textbf{X}_{10-90}(i)-\bar{X}_{10-90}|}\]

Robust Mean Absolute Deviation is the mean distance of all intensity values from the Mean Value calculated on the subset of image array with gray levels in between, or equal to the 10th and 90th percentile.

getRootMeanSquaredFeatureValue()[source]

14. Root Mean Squared (RMS)

\[\textit{RMS} = \sqrt{\frac{1}{N_p}\sum^{N_p}_{i=1}{(\textbf{X}(i) + c)^2}}\]

Here, \(c\) is optional value, defined by voxelArrayShift, which shifts the intensities to prevent negative values in \(\textbf{X}\). This ensures that voxels with the lowest gray values contribute the least to RMS, instead of voxels with gray level intensity closest to 0.

RMS is the square-root of the mean of all the squared intensity values. It is another measure of the magnitude of the image values. This feature is volume-confounded, a larger value of \(c\) increases the effect of volume-confounding.

getStandardDeviationFeatureValue()[source]

15. Standard Deviation

\[\textit{standard deviation} = \sqrt{\frac{1}{N_p}\sum^{N_p}_{i=1}{(\textbf{X}(i)-\bar{X})^2}}\]

Standard Deviation measures the amount of variation or dispersion from the Mean Value. By definition, :math:textit{standard deviation} = sqrt{textit{variance}}

Note

As this feature is correlated with variance, it is marked so it is not enabled by default. To include this feature in the extraction, specify it by name in the enabled features (i.e. this feature will not be enabled if no individual features are specified (enabling ‘all’ features), but will be enabled when individual features are specified, including this feature). Not present in IBSI feature definitions (correlated with variance)

getSkewnessFeatureValue(axis=0)[source]

16. Skewness

\[\textit{skewness} = \displaystyle\frac{\mu_3}{\sigma^3} = \frac{\frac{1}{N_p}\sum^{N_p}_{i=1}{(\textbf{X}(i)-\bar{X})^3}} {\left(\sqrt{\frac{1}{N_p}\sum^{N_p}_{i=1}{(\textbf{X}(i)-\bar{X})^2}}\right)^3}\]

Where \(\mu_3\) is the 3rd central moment.

Skewness measures the asymmetry of the distribution of values about the Mean value. Depending on where the tail is elongated and the mass of the distribution is concentrated, this value can be positive or negative.

Related links:

https://en.wikipedia.org/wiki/Skewness

Note

In case of a flat region, the standard deviation and 4rd central moment will be both 0. In this case, a value of 0 is returned.

getKurtosisFeatureValue(axis=0)[source]

17. Kurtosis

\[\textit{kurtosis} = \displaystyle\frac{\mu_4}{\sigma^4} = \frac{\frac{1}{N_p}\sum^{N_p}_{i=1}{(\textbf{X}(i)-\bar{X})^4}} {\left(\frac{1}{N_p}\sum^{N_p}_{i=1}{(\textbf{X}(i)-\bar{X}})^2\right)^2}\]

Where \(\mu_4\) is the 4th central moment.

Kurtosis is a measure of the ‘peakedness’ of the distribution of values in the image ROI. A higher kurtosis implies that the mass of the distribution is concentrated towards the tail(s) rather than towards the mean. A lower kurtosis implies the reverse: that the mass of the distribution is concentrated towards a spike near the Mean value.

Related links:

https://en.wikipedia.org/wiki/Kurtosis

Note

In case of a flat region, the standard deviation and 4rd central moment will be both 0. In this case, a value of 0 is returned.

Note

The IBSI feature definition implements excess kurtosis, where kurtosis is corrected by -3, yielding 0 for normal distributions. The PyRadiomics kurtosis is not corrected, yielding a value 3 higher than the IBSI kurtosis.

getVarianceFeatureValue()[source]

18. Variance

\[\textit{variance} = \frac{1}{N_p}\displaystyle\sum^{N_p}_{i=1}{(\textbf{X}(i)-\bar{X})^2}\]

Variance is the the mean of the squared distances of each intensity value from the Mean value. This is a measure of the spread of the distribution about the mean. By definition, \(\textit{variance} = \sigma^2\)

getUniformityFeatureValue()[source]

19. Uniformity

\[\textit{uniformity} = \displaystyle\sum^{N_g}_{i=1}{p(i)^2}\]

Uniformity is a measure of the sum of the squares of each intensity value. This is a measure of the heterogeneity of the image array, where a greater uniformity implies a greater heterogeneity or a greater range of discrete intensity values.

Note

Defined by IBSI as Intensity Histogram Uniformity.

Shape Features

class radiomics.shape.RadiomicsShape(inputImage, inputMask, **kwargs)[source]

Bases: radiomics.base.RadiomicsFeaturesBase

In this group of features we included descriptors of the three-dimensional size and shape of the ROI. These features are independent from the gray level intensity distribution in the ROI and are therefore only calculated on the non-derived image and mask.

Let:

  • \(V\) the volume of the ROI in mm3
  • \(A\) the surface area of the ROI in mm2
getVolumeFeatureValue()[source]

1. Volume

\[V = \displaystyle\sum^{N}_{i=1}{V_i}\]

The volume of the ROI \(V\) is approximated by multiplying the number of voxels in the ROI by the volume of a single voxel \(V_i\).

Note

In the IBSI feature definitions, a more precise approximation of the volume is used. That method uses tetrahedrons consisting of the origin and faces in the ROI. Although the method implemented here overestimates the volume, especially in small volumes, the difference will be negligible in large ROIs.

getSurfaceAreaFeatureValue()[source]

2. Surface Area

\[A = \displaystyle\sum^{N}_{i=1}{\frac{1}{2}|\text{a}_i\text{b}_i \times \text{a}_i\text{c}_i|}\]

Where:

\(N\) is the number of triangles forming the surface mesh of the volume (ROI)

\(\text{a}_i\text{b}_i\) and \(\text{a}_i\text{c}_i\) are the edges of the \(i^{\text{th}}\) triangle formed by points \(\text{a}_i\), \(\text{b}_i\) and \(\text{c}_i\)

Surface Area is an approximation of the surface of the ROI in mm2, calculated using a marching cubes algorithm.

References:

  • Lorensen WE, Cline HE. Marching cubes: A high resolution 3D surface construction algorithm. ACM SIGGRAPH Comput Graph Internet. 1987;21:163-9.
getSurfaceVolumeRatioFeatureValue()[source]

3. Surface Area to Volume ratio

\[\textit{surface to volume ratio} = \frac{A}{V}\]

Here, a lower value indicates a more compact (sphere-like) shape. This feature is not dimensionless, and is therefore (partly) dependent on the volume of the ROI.

getSphericityFeatureValue()[source]

4. Sphericity

\[\textit{sphericity} = \frac{\sqrt[3]{36 \pi V^2}}{A}\]

Sphericity is a measure of the roundness of the shape of the tumor region relative to a sphere. It is a dimensionless measure, independent of scale and orientation. The value range is \(0 < sphericity \leq 1\), where a value of 1 indicates a perfect sphere (a sphere has the smallest possible surface area for a given volume, compared to other solids).

Note

This feature is correlated to Compactness 1, Compactness 2 and Spherical Disproportion. In the default parameter file provided in the pyradiomics/examples/exampleSettings folder, Compactness 1 and Compactness 2 are therefore disabled.

getCompactness1FeatureValue()[source]

5. Compactness 1

\[\textit{compactness 1} = \frac{V}{\sqrt{\pi A^3}}\]

Similar to Sphericity, Compactness 1 is a measure of how compact the shape of the tumor is relative to a sphere (most compact). It is therefore correlated to Sphericity and redundant. It is provided here for completeness. The value range is \(0 < compactness\ 1 \leq \frac{1}{6 \pi}\), where a value of \(\frac{1}{6 \pi}\) indicates a perfect sphere.

By definition, \(compactness\ 1 = \frac{1}{6 \pi}\sqrt{compactness\ 2} = \frac{1}{6 \pi}\sqrt{sphericity^3}\).

Note

This feature is correlated to Compactness 2, Sphericity and Spherical Disproportion. Therefore, this feature is marked, so it is not enabled by default (i.e. this feature will not be enabled if no individual features are specified (enabling ‘all’ features), but will be enabled when individual features are specified, including this feature). To include this feature in the extraction, specify it by name in the enabled features.

getCompactness2FeatureValue()[source]

6. Compactness 2

\[\textit{compactness 2} = 36 \pi \frac{V^2}{A^3}\]

Similar to Sphericity and Compactness 1, Compactness 2 is a measure of how compact the shape of the tumor is relative to a sphere (most compact). It is a dimensionless measure, independent of scale and orientation. The value range is \(0 < compactness\ 2 \leq 1\), where a value of 1 indicates a perfect sphere.

By definition, \(compactness\ 2 = (sphericity)^3\)

Note

This feature is correlated to Compactness 1, Sphericity and Spherical Disproportion. Therefore, this feature is marked, so it is not enabled by default (i.e. this feature will not be enabled if no individual features are specified (enabling ‘all’ features), but will be enabled when individual features are specified, including this feature). To include this feature in the extraction, specify it by name in the enabled features.

getSphericalDisproportionFeatureValue()[source]

7. Spherical Disproportion

\[\textit{spherical disproportion} = \frac{A}{4\pi R^2} = \frac{A}{\sqrt[3]{36 \pi V^2}}\]

Where \(R\) is the radius of a sphere with the same volume as the tumor, and equal to \(\sqrt[3]{\frac{3V}{4\pi}}\).

Spherical Disproportion is the ratio of the surface area of the tumor region to the surface area of a sphere with the same volume as the tumor region, and by definition, the inverse of Sphericity. Therefore, the value range is \(spherical\ disproportion \geq 1\), with a value of 1 indicating a perfect sphere.

Note

This feature is correlated to Compactness 2, Compactness2 and Sphericity. Therefore, this feature is marked, so it is not enabled by default (i.e. this feature will not be enabled if no individual features are specified (enabling ‘all’ features), but will be enabled when individual features are specified, including this feature). To include this feature in the extraction, specify it by name in the enabled features.

getMaximum3DDiameterFeatureValue()[source]

8. Maximum 3D diameter

Maximum 3D diameter is defined as the largest pairwise Euclidean distance between surface voxels in the ROI.

Also known as Feret Diameter.

Warning

This feature is only available when C Extensions are enabled

getMaximum2DDiameterSliceFeatureValue()[source]

9. Maximum 2D diameter (Slice)

Maximum 2D diameter (Slice) is defined as the largest pairwise Euclidean distance between tumor surface voxels in the row-column (generally the axial) plane.

Warning

This feature is only available when C Extensions are enabled

getMaximum2DDiameterColumnFeatureValue()[source]

10. Maximum 2D diameter (Column)

Maximum 2D diameter (Column) is defined as the largest pairwise Euclidean distance between tumor surface voxels in the row-slice (usually the coronal) plane.

Warning

This feature is only available when C Extensions are enabled

getMaximum2DDiameterRowFeatureValue()[source]

11. Maximum 2D diameter (Row)

Maximum 2D diameter (Row) is defined as the largest pairwise Euclidean distance between tumor surface voxels in the column-slice (usually the sagittal) plane.

Warning

This feature is only available when C Extensions are enabled

getMajorAxisFeatureValue()[source]

12. Major Axis

\[\textit{major axis} = 4 \sqrt{\lambda_{\text{major}}}\]
getMinorAxisFeatureValue()[source]

13. Minor Axis

\[\textit{minor axis} = 4 \sqrt{\lambda_{\text{minor}}}\]
getLeastAxisFeatureValue()[source]

14. Least Axis

\[\textit{least axis} = 4 \sqrt{\lambda_{\text{least}}}\]
getElongationFeatureValue()[source]

15. Elongation

Elongation is calculated using its implementation in SimpleITK, and is defined as:

\[\textit{elongation} = \sqrt{\frac{\lambda_{\text{minor}}}{\lambda_{\text{major}}}}\]

Here, \(\lambda_{\text{major}}\) and \(\lambda_{\text{minor}}\) are the lengths of the largest and second largest principal component axes. The values range between 1 (where the cross section through the first and second largest principal moments is circle-like (non-elongated)) and 0 (where the object is a single point or 1 dimensional line).

getFlatnessFeatureValue()[source]

16. Flatness

Flatness is calculated using its implementation in SimpleITK, and is defined as:

\[\textit{flatness} = \sqrt{\frac{\lambda_{\text{least}}}{\lambda_{\text{major}}}}\]

Here, \(\lambda_{\text{major}}\) and \(\lambda_{\text{least}}\) are the lengths of the largest and smallest principal component axes. The values range between 1 (non-flat, sphere-like) and 0 (a flat object).

Gray Level Co-occurrence Matrix (GLCM) Features

class radiomics.glcm.RadiomicsGLCM(inputImage, inputMask, **kwargs)[source]

Bases: radiomics.base.RadiomicsFeaturesBase

A Gray Level Co-occurrence Matrix (GLCM) of size \(N_g \times N_g\) describes the second-order joint probability function of an image region constrained by the mask and is defined as \(\textbf{P}(i,j|\delta,\theta)\). The \((i,j)^{\text{th}}\) element of this matrix represents the number of times the combination of levels \(i\) and \(j\) occur in two pixels in the image, that are separated by a distance of \(\delta\) pixels along angle \(\theta\). The distance \(\delta\) from the center voxel is defined as the distance according to the infinity norm. For \(\delta=1\), this results in 2 neighbors for each of 13 angles in 3D (26-connectivity) and for \(\delta=2\) a 98-connectivity (49 unique angles).

Note that pyradiomics by default computes symmetrical GLCM!

As a two dimensional example, let the following matrix \(\textbf{I}\) represent a 5x5 image, having 5 discrete grey levels:

\[\begin{split}\textbf{I} = \begin{bmatrix} 1 & 2 & 5 & 2 & 3\\ 3 & 2 & 1 & 3 & 1\\ 1 & 3 & 5 & 5 & 2\\ 1 & 1 & 1 & 1 & 2\\ 1 & 2 & 4 & 3 & 5 \end{bmatrix}\end{split}\]

For distance \(\delta = 1\) (considering pixels with a distance of 1 pixel from each other) and angle \(\theta=0^\circ\) (horizontal plane, i.e. voxels to the left and right of the center voxel), the following symmetrical GLCM is obtained:

\[\begin{split}\textbf{P} = \begin{bmatrix} 6 & 4 & 3 & 0 & 0\\ 4 & 0 & 2 & 1 & 3\\ 3 & 2 & 0 & 1 & 2\\ 0 & 1 & 1 & 0 & 0\\ 0 & 3 & 2 & 0 & 2 \end{bmatrix}\end{split}\]

Let:

  • \(\epsilon\) be an arbitrarily small positive number (\(\approx 2.2\times10^{-16}\))
  • \(\textbf{P}(i,j)\) be the co-occurence matrix for an arbitrary \(\delta\) and \(\theta\)
  • \(p(i,j)\) be the normalized co-occurence matrix and equal to \(\frac{\textbf{P}(i,j)}{\sum{\textbf{P}(i,j)}}\)
  • \(N_g\) be the number of discrete intensity levels in the image
  • \(p_x(i) = \sum^{N_g}_{j=1}{P(i,j)}\) be the marginal row probabilities
  • \(p_y(j) = \sum^{N_g}_{i=1}{P(i,j)}\) be the marginal column probabilities
  • \(\mu_x\) be the mean gray level intensity of \(p_x\) and defined as \(\mu_x = \displaystyle\sum^{N_g}_{i=1}{p_x(i)i}\)
  • \(\mu_y\) be the mean gray level intensity of \(p_y\) and defined as \(\mu_y = \displaystyle\sum^{N_g}_{j=1}{p_y(j)j}\)
  • \(\sigma_x\) be the standard deviation of \(p_x\)
  • \(\sigma_y\) be the standard deviation of \(p_y\)
  • \(p_{x+y}(k) = \sum^{N_g}_{i=1}\sum^{N_g}_{j=1}{p(i,j)},\text{ where }i+j=k,\text{ and }k=2,3,\dots,2N_g\)
  • \(p_{x-y}(k) = \sum^{N_g}_{i=1}\sum^{N_g}_{j=1}{p(i,j)},\text{ where }|i-j|=k,\text{ and }k=0,1,\dots,N_g-1\)
  • \(HX = -\sum^{N_g}_{i=1}{p_x(i)\log_2\big(p_x(i)+\epsilon\big)}\) be the entropy of \(p_x\)
  • \(HY = -\sum^{N_g}_{j=1}{p_y(j)\log_2\big(p_y(j)+\epsilon\big)}\) be the entropy of \(p_y\)
  • \(HXY = -\sum^{N_g}_{i=1}\sum^{N_g}_{j=1}{p(i,j)\log_2\big(p(i,j)+\epsilon\big)}\) be the entropy of \(p(i,j)\)
  • \(HXY1 = -\sum^{N_g}_{i=1}\sum^{N_g}_{j=1}{p(i,j)\log_2\big(p_x(i)p_y(j)+\epsilon\big)}\)
  • \(HXY2 = -\sum^{N_g}_{i=1}\sum^{N_g}_{j=1}{p_x(i)p_y(j)\log_2\big(p_x(i)p_y(j)+\epsilon\big)}\)

By default, the value of a feature is calculated on the GLCM for each angle separately, after which the mean of these values is returned. If distance weighting is enabled, GLCM matrices are weighted by weighting factor W and then summed and normalised. Features are then calculated on the resultant matrix. Weighting factor W is calculated for the distance between neighbouring voxels by:

\(W = e^{-\|d\|^2}\), where d is the distance for the associated angle according to the norm specified in setting ‘weightingNorm’.

The following class specific settings are possible:

  • distances [[1]]: List of integers. This specifies the distances between the center voxel and the neighbor, for which angles should be generated. See also generateAngles()

  • symmetricalGLCM [True]: boolean, indicates whether co-occurrences should be assessed in two directions per angle, which results in a symmetrical matrix, with equal distributions for \(i\) and \(j\). A symmetrical matrix corresponds to the GLCM as defined by Haralick et al.

  • weightingNorm [None]: string, indicates which norm should be used when applying distance weighting. Enumerated setting, possible values:

    • ‘manhattan’: first order norm
    • ‘euclidean’: second order norm
    • ‘infinity’: infinity norm.
    • ‘no_weighting’: GLCMs are weighted by factor 1 and summed
    • None: Applies no weighting, mean of values calculated on separate matrices is returned.

    In case of other values, an warning is logged and option ‘no_weighting’ is used.

References

getAutocorrelationFeatureValue()[source]

1. Autocorrelation

\[\textit{autocorrelation} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1}{p(i,j)ij}\]

Autocorrelation is a measure of the magnitude of the fineness and coarseness of texture.

getJointAverageFeatureValue()[source]

2. Joint Average

\[\textit{joint average} = \mu_x = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1}{p(i,j)i}\]

Returns the mean gray level intensity of the \(i\) distribution.

Warning

As this formula represents the average of the distribution of \(i\), it is independent from the distribution of \(j\). Therefore, only use this formula if the GLCM is symmetrical, where \(p_x(i) = p_y(j) \text{, where } i = j\).

getClusterProminenceFeatureValue()[source]

3. Cluster Prominence

\[\textit{cluster prominence} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1} {\big( i+j-\mu_x-\mu_y\big)^4p(i,j)}\]

Cluster Prominence is a measure of the skewness and asymmetry of the GLCM. A higher values implies more asymmetry about the mean while a lower value indicates a peak near the mean value and less variation about the mean.

getClusterShadeFeatureValue()[source]

4. Cluster Shade

\[\textit{cluster shade} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1} {\big(i+j-\mu_x-\mu_y\big)^3p(i,j)}\]

Cluster Shade is a measure of the skewness and uniformity of the GLCM. A higher cluster shade implies greater asymmetry about the mean.

getClusterTendencyFeatureValue()[source]

5. Cluster Tendency

\[\textit{cluster tendency} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1} {\big(i+j-\mu_x-\mu_y\big)^2p(i,j)}\]

Cluster Tendency is a measure of groupings of voxels with similar gray-level values.

getContrastFeatureValue()[source]

6. Contrast

\[\textit{contrast} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1}{(i-j)^2p(i,j)}\]

Contrast is a measure of the local intensity variation, favoring values away from the diagonal \((i = j)\). A larger value correlates with a greater disparity in intensity values among neighboring voxels.

getCorrelationFeatureValue()[source]

7. Correlation

\[\textit{correlation} = \frac{\sum^{N_g}_{i=1}\sum^{N_g}_{j=1}{p(i,j)ij-\mu_x\mu_y}}{\sigma_x(i)\sigma_y(j)}\]

Correlation is a value between 0 (uncorrelated) and 1 (perfectly correlated) showing the linear dependency of gray level values to their respective voxels in the GLCM.

Note

When there is only 1 discreet gray value in the ROI (flat region), \(\sigma_x\) and \(\sigma_y\) will be 0. In this case, an arbitrary value of 1 is returned instead. This is assessed on a per-angle basis.

getDifferenceAverageFeatureValue()[source]

8. Difference Average

\[\textit{difference average} = \displaystyle\sum^{N_g-1}_{k=0}{kp_{x-y}(k)}\]

Difference Average measures the relationship between occurrences of pairs with similar intensity values and occurrences of pairs with differing intensity values.

getDifferenceEntropyFeatureValue()[source]

9. Difference Entropy

\[\textit{difference entropy} = \displaystyle\sum^{N_g-1}_{k=0}{p_{x-y}(k)\log_2\big(p_{x-y}(k)+\epsilon\big)}\]

Difference Entropy is a measure of the randomness/variability in neighborhood intensity value differences.

getDifferenceVarianceFeatureValue()[source]

10. Difference Variance

\[\textit{difference variance} = \displaystyle\sum^{N_g-1}_{k=0}{(k-DA)^2p_{x-y}(k)}\]

Difference Variance is a measure of heterogeneity that places higher weights on differing intensity level pairs that deviate more from the mean.

getDissimilarityFeatureValue()[source]

DEPRECATED. Dissimilarity

\[\textit{dissimilarity} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1}{|i-j|p(i,j)}\]

Warning

This feature has been deprecated, as it is mathematically equal to Difference Average getDifferenceAverageFeatureValue(). See here for the proof. Enabling this feature will result in the logging of a DeprecationWarning (does not interrupt extraction of other features), no value is calculated for this features

getJointEnergyFeatureValue()[source]

11. Joint Energy

\[\textit{joint energy} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1}{\big(p(i,j)\big)^2}\]

Energy is a measure of homogeneous patterns in the image. A greater Energy implies that there are more instances of intensity value pairs in the image that neighbor each other at higher frequencies.

Note

Defined by IBSI as Angular Second Moment.

getJointEntropyFeatureValue()[source]

12. Joint Entropy

\[\textit{joint entropy} = -\displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1} {p(i,j)\log_2\big(p(i,j)+\epsilon\big)}\]

Joint entropy is a measure of the randomness/variability in neighborhood intensity values.

Note

Defined by IBSI as Joint entropy

getHomogeneity1FeatureValue()[source]

DEPRECATED. Homogeneity 1

\[\textit{homogeneity 1} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1}{\frac{p(i,j)}{1+|i-j|}}\]

Warning

This feature has been deprecated, as it is mathematically equal to Inverse Difference getIdFeatureValue(). Enabling this feature will result in the logging of a DeprecationWarning (does not interrupt extraction of other features), no value is calculated for this features

getHomogeneity2FeatureValue()[source]

DEPRECATED. Homogeneity 2

\[\textit{homogeneity 2} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1}{\frac{p(i,j)}{1+|i-j|^2}}\]

Warning

This feature has been deprecated, as it is mathematically equal to Inverse Difference Moment getIdmFeatureValue(). Enabling this feature will result in the logging of a DeprecationWarning (does not interrupt extraction of other features), no value is calculated for this features

getImc1FeatureValue()[source]

13. Informal Measure of Correlation (IMC) 1

\[\textit{IMC 1} = \frac{HXY-HXY1}{\max\{HX,HY\}}\]

Note

In the case where both HX and HY are 0 (as is the case in a flat region), an arbitrary value of 0 is returned to prevent a division by 0. This is done on a per-angle basis

getImc2FeatureValue()[source]

14. Informal Measure of Correlation (IMC) 2

\[\textit{IMC 2} = \sqrt{1-e^{-2(HXY2-HXY)}}\]

Note

In the case where HXY = HXY2, an arbitrary value of 0 is returned to prevent returning complex numbers. This is done on a per-angle basis.

getIdmFeatureValue()[source]

15. Inverse Difference Moment (IDM)

\[\textit{IDM} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1}{ \frac{p(i,j)}{1+|i-j|^2} }\]

IDM (a.k.a Homogeneity 2) is a measure of the local homogeneity of an image. IDM weights are the inverse of the Contrast weights (decreasing exponentially from the diagonal i=j in the GLCM).

getIdmnFeatureValue()[source]

16. Inverse Difference Moment Normalized (IDMN)

\[\textit{IDMN} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1} { \frac{p(i,j)}{1+\left(\frac{|i-j|^2}{N_g^2}\right)} }\]

IDMN (inverse difference moment normalized) is a measure of the local homogeneity of an image. IDMN weights are the inverse of the Contrast weights (decreasing exponentially from the diagonal \(i=j\) in the GLCM). Unlike Homogeneity2, IDMN normalizes the square of the difference between neighboring intensity values by dividing over the square of the total number of discrete intensity values.

getIdFeatureValue()[source]

17. Inverse Difference (ID)

\[\textit{ID} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1}{ \frac{p(i,j)}{1+|i-j|} }\]

ID (a.k.a. Homogeneity 1) is another measure of the local homogeneity of an image. With more uniform gray levels, the denominator will remain low, resulting in a higher overall value.

getIdnFeatureValue()[source]

18. Inverse Difference Normalized (IDN)

\[\textit{IDN} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1} { \frac{p(i,j)}{1+\left(\frac{|i-j|}{N_g}\right)} }\]

IDN (inverse difference normalized) is another measure of the local homogeneity of an image. Unlike Homogeneity1, IDN normalizes the difference between the neighboring intensity values by dividing over the total number of discrete intensity values.

getInverseVarianceFeatureValue()[source]

19. Inverse Variance

\[\textit{inverse variance} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1}{\frac{p(i,j)}{|i-j|^2}}, i \neq j\]
getMaximumProbabilityFeatureValue()[source]

20. Maximum Probability

\[\textit{maximum probability} = \max\big(p(i,j)\big)\]

Maximum Probability is occurrences of the most predominant pair of neighboring intensity values.

Note

Defined by IBSI as Joint maximum

getSumAverageFeatureValue()[source]

21. Sum Average

\[\textit{sum average} = \displaystyle\sum^{2N_g}_{k=2}{p_{x+y}(k)k}\]

Sum Average measures the relationship between occurrences of pairs with lower intensity values and occurrences of pairs with higher intensity values.

Warning

When GLCM is symmetrical, \(\mu_x = \mu_y\), and therefore \(\text{Sum Average} = \mu_x + \mu_y = 2 \mu_x = 2 * Joint Average\). See formulas (4.), (5.) and (6.) defined here for the proof that \(\text{Sum Average} = \mu_x + \mu_y\). In the default parameter files provided in the examples/exampleSettings, this feature has been disabled.

getSumVarianceFeatureValue()[source]

DEPRECATED. Sum Variance

\[\textit{sum variance} = \displaystyle\sum^{2N_g}_{k=2}{(k-SA)^2p_{x+y}(k)}\]

Warning

This feature has been deprecated, as it is mathematically equal to Cluster Tendency getClusterTendencyFeatureValue(). See here for the proof. Enabling this feature will result in the logging of a DeprecationWarning (does not interrupt extraction of other features), no value is calculated for this features

getSumEntropyFeatureValue()[source]

22. Sum Entropy

\[\textit{sum entropy} = \displaystyle\sum^{2N_g}_{k=2}{p_{x+y}(k)\log_2\big(p_{x+y}(k)+\epsilon\big)}\]

Sum Entropy is a sum of neighborhood intensity value differences.

getSumSquaresFeatureValue()[source]

23. Sum of Squares

\[\textit{sum squares} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1}{(i-\mu_x)^2p(i,j)}\]

Sum of Squares or Variance is a measure in the distribution of neigboring intensity level pairs about the mean intensity level in the GLCM.

Warning

This formula represents the variance of the distribution of \(i\) and is independent from the distribution of \(j\). Therefore, only use this formula if the GLCM is symmetrical, where \(p_x(i) = p_y(j) \text{, where } i = j\)

Note

Defined by IBSI as Joint Variance

Gray Level Size Zone Matrix (GLSZM) Features

class radiomics.glszm.RadiomicsGLSZM(inputImage, inputMask, **kwargs)[source]

Bases: radiomics.base.RadiomicsFeaturesBase

A Gray Level Size Zone (GLSZM) quantifies gray level zones in an image. A gray level zone is defined as a the number of connected voxels that share the same gray level intensity. A voxel is considered connected if the distance is 1 according to the infinity norm (26-connected region in a 3D, 8-connected region in 2D). In a gray level size zone matrix \(P(i,j)\) the \((i,j)^{\text{th}}\) element equals the number of zones with gray level \(i\) and size \(j\) appear in image. Contrary to GLCM and GLRLM, the GLSZM is rotation independent, with only one matrix calculated for all directions in the ROI.

As a two dimensional example, consider the following 5x5 image, with 5 discrete gray levels:

\[\begin{split}\textbf{I} = \begin{bmatrix} 5 & 2 & 5 & 4 & 4\\ 3 & 3 & 3 & 1 & 3\\ 2 & 1 & 1 & 1 & 3\\ 4 & 2 & 2 & 2 & 3\\ 3 & 5 & 3 & 3 & 2 \end{bmatrix}\end{split}\]

The GLSZM then becomes:

\[\begin{split}\textbf{P} = \begin{bmatrix} 0 & 0 & 0 & 1 & 0\\ 1 & 0 & 0 & 0 & 1\\ 1 & 0 & 1 & 0 & 1\\ 1 & 1 & 0 & 0 & 0\\ 3 & 0 & 0 & 0 & 0 \end{bmatrix}\end{split}\]

Let:

  • \(N_g\) be the number of discreet intensity values in the image
  • \(N_s\) be the number of discreet zone sizes in the image
  • \(N_p\) be the number of voxels in the image
  • \(N_z\) be the number of zones in the ROI, which is equal to \(\sum^{N_g}_{i=1}\sum^{N_s}_{j=1} {\textbf{P}(i,j)}\) and \(1 \leq N_z \leq N_p\)
  • \(\textbf{P}(i,j)\) be the size zone matrix
  • \(p(i,j)\) be the normalized size zone matrix, defined as \(p(i,j) = \frac{\textbf{P}(i,j)}{N_z}\)

Note

The mathematical formulas that define the GLSZM features correspond to the definitions of features extracted from the GLRLM.

References

  • Guillaume Thibault; Bernard Fertil; Claire Navarro; Sandrine Pereira; Pierre Cau; Nicolas Levy; Jean Sequeira; Jean-Luc Mari (2009). “Texture Indexes and Gray Level Size Zone Matrix. Application to Cell Nuclei Classification”. Pattern Recognition and Information Processing (PRIP): 140-145.
  • https://en.wikipedia.org/wiki/Gray_level_size_zone_matrix
getSmallAreaEmphasisFeatureValue()[source]

1. Small Area Emphasis (SAE)

\[\textit{SAE} = \frac{\sum^{N_g}_{i=1}\sum^{N_s}_{j=1}{\frac{\textbf{P}(i,j)}{j^2}}}{N_z}\]

SAE is a measure of the distribution of small size zones, with a greater value indicative of more smaller size zones and more fine textures.

getLargeAreaEmphasisFeatureValue()[source]

2. Large Area Emphasis (LAE)

\[\textit{LAE} = \frac{\sum^{N_g}_{i=1}\sum^{N_s}_{j=1}{\textbf{P}(i,j)j^2}}{N_z}\]

LAE is a measure of the distribution of large area size zones, with a greater value indicative of more larger size zones and more coarse textures.

getGrayLevelNonUniformityFeatureValue()[source]

3. Gray Level Non-Uniformity (GLN)

\[\textit{GLN} = \frac{\sum^{N_g}_{i=1}\left(\sum^{N_s}_{j=1}{\textbf{P}(i,j)}\right)^2}{N_z}\]

GLN measures the variability of gray-level intensity values in the image, with a lower value indicating more homogeneity in intensity values.

getGrayLevelNonUniformityNormalizedFeatureValue()[source]

4. Gray Level Non-Uniformity Normalized (GLNN)

\[\textit{GLNN} = \frac{\sum^{N_g}_{i=1}\left(\sum^{N_s}_{j=1}{\textbf{P}(i,j)}\right)^2}{N_z^2}\]

GLNN measures the variability of gray-level intensity values in the image, with a lower value indicating a greater similarity in intensity values. This is the normalized version of the GLN formula.

getSizeZoneNonUniformityFeatureValue()[source]

5. Size-Zone Non-Uniformity (SZN)

\[\textit{SZN} = \frac{\sum^{N_s}_{j=1}\left(\sum^{N_g}_{i=1}{\textbf{P}(i,j)}\right)^2}{N_z}\]

SZN measures the variability of size zone volumes in the image, with a lower value indicating more homogeneity in size zone volumes.

getSizeZoneNonUniformityNormalizedFeatureValue()[source]

6. Size-Zone Non-Uniformity Normalized (SZNN)

\[\textit{SZNN} = \frac{\sum^{N_s}_{j=1}\left(\sum^{N_g}_{i=1}{\textbf{P}(i,j)}\right)^2}{N_z^2}\]

SZNN measures the variability of size zone volumes throughout the image, with a lower value indicating more homogeneity among zone size volumes in the image. This is the normalized version of the SZN formula.

getZonePercentageFeatureValue()[source]

7. Zone Percentage (ZP)

\[\textit{ZP} = \frac{N_z}{N_p}\]

ZP measures the coarseness of the texture by taking the ratio of number of zones and number of voxels in the ROI.

Values are in range \(\frac{1}{N_p} \leq ZP \leq 1\), with higher values indicating a larger portion of the ROI consists of small zones (indicates a more fine texture).

getGrayLevelVarianceFeatureValue()[source]

8. Gray Level Variance (GLV)

\[\textit{GLV} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_s}_{j=1}{p(i,j)(i - \mu)^2}\]

Here, \(\mu = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_s}_{j=1}{p(i,j)i}\)

GLV measures the variance in gray level intensities for the zones.

getZoneVarianceFeatureValue()[source]

9. Zone Variance (ZV)

\[\textit{ZV} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_s}_{j=1}{p(i,j)(j - \mu)^2}\]

Here, \(\mu = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_s}_{j=1}{p(i,j)j}\)

ZV measures the variance in zone size volumes for the zones.

getZoneEntropyFeatureValue()[source]

10. Zone Entropy (ZE)

\[\textit{ZE} = -\displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_s}_{j=1}{p(i,j)\log_{2}(p(i,j)+\epsilon)}\]

Here, \(\epsilon\) is an arbitrarily small positive number (\(\approx 2.2\times10^{-16}\)).

ZE measures the uncertainty/randomness in the distribution of zone sizes and gray levels. A higher value indicates more heterogeneneity in the texture patterns.

getLowGrayLevelZoneEmphasisFeatureValue()[source]

11. Low Gray Level Zone Emphasis (LGLZE)

\[\textit{LGLZE} = \frac{\sum^{N_g}_{i=1}\sum^{N_s}_{j=1}{\frac{\textbf{P}(i,j)}{i^2}}}{N_z}\]

LGLZE measures the distribution of lower gray-level size zones, with a higher value indicating a greater proportion of lower gray-level values and size zones in the image.

getHighGrayLevelZoneEmphasisFeatureValue()[source]

12. High Gray Level Zone Emphasis (HGLZE)

\[\textit{HGLZE} = \frac{\sum^{N_g}_{i=1}\sum^{N_s}_{j=1}{\textbf{P}(i,j)i^2}}{N_z}\]

HGLZE measures the distribution of the higher gray-level values, with a higher value indicating a greater proportion of higher gray-level values and size zones in the image.

getSmallAreaLowGrayLevelEmphasisFeatureValue()[source]

13. Small Area Low Gray Level Emphasis (SALGLE)

\[\textit{SALGLE} = \frac{\sum^{N_g}_{i=1}\sum^{N_s}_{j=1}{\frac{\textbf{P}(i,j)}{i^2j^2}}}{N_z}\]

SALGLE measures the proportion in the image of the joint distribution of smaller size zones with lower gray-level values.

getSmallAreaHighGrayLevelEmphasisFeatureValue()[source]

14. Small Area High Gray Level Emphasis (SAHGLE)

\[\textit{SAHGLE} = \frac{\sum^{N_g}_{i=1}\sum^{N_s}_{j=1}{\frac{\textbf{P}(i,j)i^2}{j^2}}}{N_z}\]

SAHGLE measures the proportion in the image of the joint distribution of smaller size zones with higher gray-level values.

getLargeAreaLowGrayLevelEmphasisFeatureValue()[source]

15. Large Area Low Gray Level Emphasis (LALGLE)

\[\textit{LALGLE} = \frac{\sum^{N_g}_{i=1}\sum^{N_s}_{j=1}{\frac{\textbf{P}(i,j)j^2}{i^2}}}{N_z}\]

LALGLE measures the proportion in the image of the joint distribution of larger size zones with lower gray-level values.

getLargeAreaHighGrayLevelEmphasisFeatureValue()[source]

16. Large Area High Gray Level Emphasis (LAHGLE)

\[\textit{LAHGLE} = \frac{\sum^{N_g}_{i=1}\sum^{N_s}_{j=1}{\textbf{P}(i,j)i^2j^2}}{N_z}\]

LAHGLE measures the proportion in the image of the joint distribution of larger size zones with higher gray-level values.

Gray Level Run Length Matrix (GLRLM) Features

class radiomics.glrlm.RadiomicsGLRLM(inputImage, inputMask, **kwargs)[source]

Bases: radiomics.base.RadiomicsFeaturesBase

A Gray Level Run Length Matrix (GLRLM) quantifies gray level runs, which are defined as the length in number of pixels, of consecutive pixels that have the same gray level value. In a gray level run length matrix \(\textbf{P}(i,j|\theta)\), the \((i,j)^{\text{th}}\) element describes the number of runs with gray level \(i\) and length \(j\) occur in the image (ROI) along angle \(\theta\).

As a two dimensional example, consider the following 5x5 image, with 5 discrete gray levels:

\[\begin{split}\textbf{I} = \begin{bmatrix} 5 & 2 & 5 & 4 & 4\\ 3 & 3 & 3 & 1 & 3\\ 2 & 1 & 1 & 1 & 3\\ 4 & 2 & 2 & 2 & 3\\ 3 & 5 & 3 & 3 & 2 \end{bmatrix}\end{split}\]

The GLRLM for \(\theta = 0\), where 0 degrees is the horizontal direction, then becomes:

\[\begin{split}\textbf{P} = \begin{bmatrix} 1 & 0 & 1 & 0 & 0\\ 3 & 0 & 1 & 0 & 0\\ 4 & 1 & 1 & 0 & 0\\ 1 & 1 & 0 & 0 & 0\\ 3 & 0 & 0 & 0 & 0 \end{bmatrix}\end{split}\]

Let:

  • \(N_g\) be the number of discreet intensity values in the image
  • \(N_r\) be the number of discreet run lengths in the image
  • \(N_p\) be the number of voxels in the image
  • \(N_z(\theta)\) be the number of runs in the image along angle \(\theta\), which is equal to \(\sum^{N_g}_{i=1}\sum^{N_r}_{j=1}{\textbf{P}(i,j|\theta)}\) and \(1 \leq N_z(\theta) \leq N_p\)
  • \(\textbf{P}(i,j|\theta)\) be the run length matrix for an arbitrary direction \(\theta\)
  • \(p(i,j|\theta)\) be the normalized run length matrix, defined as \(p(i,j|\theta) = \frac{\textbf{P}(i,j|\theta)}{N_z(\theta)}\)

By default, the value of a feature is calculated on the GLRLM for each angle separately, after which the mean of these values is returned. If distance weighting is enabled, GLRLMs are weighted by the distance between neighbouring voxels and then summed and normalised. Features are then calculated on the resultant matrix. The distance between neighbouring voxels is calculated for each angle using the norm specified in ‘weightingNorm’.

The following class specific settings are possible:

  • weightingNorm [None]: string, indicates which norm should be used when applying distance weighting. Enumerated setting, possible values:

    • ‘manhattan’: first order norm
    • ‘euclidean’: second order norm
    • ‘infinity’: infinity norm.
    • ‘no_weighting’: GLCMs are weighted by factor 1 and summed
    • None: Applies no weighting, mean of values calculated on separate matrices is returned.

    In case of other values, an warning is logged and option ‘no_weighting’ is used.

References

  • Galloway MM. 1975. Texture analysis using gray level run lengths. Computer Graphics and Image Processing, 4(2):172-179.
  • Chu A., Sehgal C.M., Greenleaf J. F. 1990. Use of gray value distribution of run length for texture analysis. Pattern Recognition Letters, 11(6):415-419
  • Xu D., Kurani A., Furst J., Raicu D. 2004. Run-Length Encoding For Volumetric Texture. International Conference on Visualization, Imaging and Image Processing (VIIP), p. 452-458
  • Tang X. 1998. Texture information in run-length matrices. IEEE Transactions on Image Processing 7(11):1602-1609.
  • Tustison N., Gee J. Run-Length Matrices For Texture Analysis. Insight Journal 2008 January - June.
getShortRunEmphasisFeatureValue()[source]

1. Short Run Emphasis (SRE)

\[\textit{SRE} = \frac{\sum^{N_g}_{i=1}\sum^{N_r}_{j=1}{\frac{\textbf{P}(i,j|\theta)}{j^2}}}{N_z(\theta)}\]

SRE is a measure of the distribution of short run lengths, with a greater value indicative of shorter run lengths and more fine textural textures.

getLongRunEmphasisFeatureValue()[source]

2. Long Run Emphasis (LRE)

\[\textit{LRE} = \frac{\sum^{N_g}_{i=1}\sum^{N_r}_{j=1}{\textbf{P}(i,j|\theta)j^2}}{N_z(\theta)}\]

LRE is a measure of the distribution of long run lengths, with a greater value indicative of longer run lengths and more coarse structural textures.

getGrayLevelNonUniformityFeatureValue()[source]

3. Gray Level Non-Uniformity (GLN)

\[\textit{GLN} = \frac{\sum^{N_g}_{i=1}\left(\sum^{N_r}_{j=1}{\textbf{P}(i,j|\theta)}\right)^2}{N_z(\theta)}\]

GLN measures the similarity of gray-level intensity values in the image, where a lower GLN value correlates with a greater similarity in intensity values.

getGrayLevelNonUniformityNormalizedFeatureValue()[source]

4. Gray Level Non-Uniformity Normalized (GLNN)

\[\textit{GLNN} = \frac{\sum^{N_g}_{i=1}\left(\sum^{N_r}_{j=1}{\textbf{P}(i,j|\theta)}\right)^2}{N_z(\theta)^2}\]

GLNN measures the similarity of gray-level intensity values in the image, where a lower GLNN value correlates with a greater similarity in intensity values. This is the normalized version of the GLN formula.

getRunLengthNonUniformityFeatureValue()[source]

5. Run Length Non-Uniformity (RLN)

\[\textit{RLN} = \frac{\sum^{N_r}_{j=1}\left(\sum^{N_g}_{i=1}{\textbf{P}(i,j|\theta)}\right)^2}{N_z(\theta)}\]

RLN measures the similarity of run lengths throughout the image, with a lower value indicating more homogeneity among run lengths in the image.

getRunLengthNonUniformityNormalizedFeatureValue()[source]

6. Run Length Non-Uniformity Normalized (RLNN)

\[\textit{RLNN} = \frac{\sum^{N_r}_{j=1}\left(\sum^{N_g}_{i=1}{\textbf{P}(i,j|\theta)}\right)^2}{N_z(\theta)^2}\]

RLNN measures the similarity of run lengths throughout the image, with a lower value indicating more homogeneity among run lengths in the image. This is the normalized version of the RLN formula.

getRunPercentageFeatureValue()[source]

7. Run Percentage (RP)

\[\textit{RP} = {\frac{N_z(\theta)}{N_p}}\]

RP measures the coarseness of the texture by taking the ratio of number of runs and number of voxels in the ROI.

Values are in range \(\frac{1}{N_p} \leq RP \leq 1\), with higher values indicating a larger portion of the ROI consists of short runs (indicates a more fine texture).

Note

Note that when weighting is applied and matrices are merged before calculation, \(N_p\) is multiplied by \(n\) number of matrices merged to ensure correct normalization (as each voxel is considered \(n\) times)

getGrayLevelVarianceFeatureValue()[source]

8. Gray Level Variance (GLV)

\[\textit{GLV} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_r}_{j=1}{p(i,j|\theta)(i - \mu)^2}\]

Here, \(\mu = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_r}_{j=1}{p(i,j|\theta)i}\)

GLV measures the variance in gray level intensity for the runs.

getRunVarianceFeatureValue()[source]

9. Run Variance (RV)

\[\textit{RV} = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_r}_{j=1}{p(i,j|\theta)(j - \mu)^2}\]

Here, \(\mu = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_r}_{j=1}{p(i,j|\theta)j}\)

RV is a measure of the variance in runs for the run lengths.

getRunEntropyFeatureValue()[source]

10. Run Entropy (RE)

\[\textit{RE} = -\displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_r}_{j=1} {p(i,j|\theta)\log_{2}(p(i,j|\theta)+\epsilon)}\]

Here, \(\epsilon\) is an arbitrarily small positive number (\(\approx 2.2\times10^{-16}\)).

RE measures the uncertainty/randomness in the distribution of run lengths and gray levels. A higher value indicates more heterogeneity in the texture patterns.

getLowGrayLevelRunEmphasisFeatureValue()[source]

11. Low Gray Level Run Emphasis (LGLRE)

\[\textit{LGLRE} = \frac{\sum^{N_g}_{i=1}\sum^{N_r}_{j=1}{\frac{\textbf{P}(i,j|\theta)}{i^2}}}{N_z(\theta)}\]

LGLRE measures the distribution of low gray-level values, with a higher value indicating a greater concentration of low gray-level values in the image.

getHighGrayLevelRunEmphasisFeatureValue()[source]

12. High Gray Level Run Emphasis (HGLRE)

\[\textit{HGLRE} = \frac{\sum^{N_g}_{i=1}\sum^{N_r}_{j=1}{\textbf{P}(i,j|\theta)i^2}}{N_z(\theta)}\]

HGLRE measures the distribution of the higher gray-level values, with a higher value indicating a greater concentration of high gray-level values in the image.

getShortRunLowGrayLevelEmphasisFeatureValue()[source]

13. Short Run Low Gray Level Emphasis (SRLGLE)

\[\textit{SRLGLE} = \frac{\sum^{N_g}_{i=1}\sum^{N_r}_{j=1}{\frac{\textbf{P}(i,j|\theta)}{i^2j^2}}}{N_z(\theta)}\]

SRLGLE measures the joint distribution of shorter run lengths with lower gray-level values.

getShortRunHighGrayLevelEmphasisFeatureValue()[source]

14. Short Run High Gray Level Emphasis (SRHGLE)

\[\textit{SRHGLE} = \frac{\sum^{N_g}_{i=1}\sum^{N_r}_{j=1}{\frac{\textbf{P}(i,j|\theta)i^2}{j^2}}}{N_z(\theta)}\]

SRHGLE measures the joint distribution of shorter run lengths with higher gray-level values.

getLongRunLowGrayLevelEmphasisFeatureValue()[source]

15. Long Run Low Gray Level Emphasis (LRLGLE)

\[\textit{LRLGLRE} = \frac{\sum^{N_g}_{i=1}\sum^{N_r}_{j=1}{\frac{\textbf{P}(i,j|\theta)j^2}{i^2}}}{N_z(\theta)}\]

LRLGLRE measures the joint distribution of long run lengths with lower gray-level values.

getLongRunHighGrayLevelEmphasisFeatureValue()[source]

16. Long Run High Gray Level Emphasis (LRHGLE)

\[\textit{LRHGLRE} = \frac{\sum^{N_g}_{i=1}\sum^{N_r}_{j=1}{\textbf{P}(i,j|\theta)i^2j^2}}{N_z(\theta)}\]

LRHGLRE measures the joint distribution of long run lengths with higher gray-level values.

Neigbouring Gray Tone Difference Matrix (NGTDM) Features

class radiomics.ngtdm.RadiomicsNGTDM(inputImage, inputMask, **kwargs)[source]

Bases: radiomics.base.RadiomicsFeaturesBase

A Neighbouring Gray Tone Difference Matrix quantifies the difference between a gray value and the average gray value of its neighbours within distance \(\delta\). The sum of absolute differences for gray level \(i\) is stored in the matrix. Let \(\textbf{X}_{gl}\) be a set of segmented voxels and \(x_{gl}(j_x,j_y,j_z) \in \textbf{X}_{gl}\) be the gray level of a voxel at postion \((j_x,j_y,j_z)\), then the average gray level of the neigbourhood is:

\[\begin{split}\bar{A}_i &= \bar{A}(j_x, j_y, j_z) \\ &= \displaystyle\frac{1}{W} \displaystyle\sum_{k_x=-\delta}^{\delta}\displaystyle\sum_{k_y=-\delta}^{\delta} \displaystyle\sum_{k_z=-\delta}^{\delta}{x_{gl}(j_x+k_x, j_y+k_y, j_z+k_z)}, \\ &\mbox{where }(k_x,k_y,k_z)\neq(0,0,0)\mbox{ and } x_{gl}(j_x+k_x, j_y+k_y, j_z+k_z) \in \textbf{X}_{gl}\end{split}\]

Here, \(W\) is the number of voxels in the neighbourhood that are also in \(\textbf{X}_{gl}\).

As a two dimensional example, let the following matrix \(\textbf{I}\) represent a 4x4 image, having 5 discrete grey levels, but no voxels with gray level 4:

\[\begin{split}\textbf{I} = \begin{bmatrix} 1 & 2 & 5 & 2\\ 3 & 5 & 1 & 3\\ 1 & 3 & 5 & 5\\ 3 & 1 & 1 & 1\end{bmatrix}\end{split}\]

The following NGTDM can be obtained:

\[\begin{split}\begin{array}{cccc} i & n_i & p_i & s_i\\ \hline 1 & 6 & 0.375 & 13.35\\ 2 & 2 & 0.125 & 2.00\\ 3 & 4 & 0.25 & 2.63\\ 4 & 0 & 0.00 & 0.00\\ 5 & 4 & 0.25 & 10.075\end{array}\end{split}\]

6 pixels have gray level 1, therefore:

\(s_1 = |1-10/3| + |1-30/8| + |1-15/5| + |1-13/5| + |1-15/5| + |1-11/3| = 13.35\)

For gray level 2, there are 2 pixels, therefore:

\(s_2 = |2-15/5| + |2-15/5| = 2\)

Similar for gray values 3 and 5:

\(s_3 = |3-14/5| + |3-18/5| + |3-20/8| + |3-5/3| = 2.63 \\ s_5 = |5-14/5| + |5-18/5| + |5-20/8| + |5-11/5| = 10.075\)

Let:

\(n_i\) be the number of voxels in \(X_{gl}\) with gray level \(i\)

\(N_v\) be the total number of voxels in \(X_{gl}\) and equal to \(\sum{n_i}\)

\(p_i\) be the gray level probability and equal to \(n_i/N_v\)

\(s_i = \left\{ {\begin{array} {rcl} \sum^{n_i}{|i-\bar{A}_i|} & \mbox{for} & n_i \neq 0 \\ 0 & \mbox{for} & n_i = 0 \end{array}}\right.\) be the sum of absolute differences for gray level \(i\)

\(N_g\) be the number of discreet gray levels

\(N_{g,p}\) be the number of gray levels where \(p_i \neq 0\)

The following class specific settings are possible:

  • distances [[1]]: List of integers. This specifies the distances between the center voxel and the neighbor, for which angles should be generated. See also generateAngles()

References

  • Amadasun M, King R; Textural features corresponding to textural properties; Systems, Man and Cybernetics, IEEE Transactions on 19:1264-1274 (1989). doi: 10.1109/21.44046
getCoarsenessFeatureValue()[source]

Calculate and return the coarseness.

\(Coarseness = \frac{1}{\sum^{N_g}_{i=1}{p_{i}s_{i}}}\)

Coarseness is a measure of average difference between the center voxel and its neighbourhood and is an indication of the spatial rate of change. A higher value indicates a lower spatial change rate and a locally more uniform texture.

N.B. \(\sum^{N_g}_{i=1}{p_{i}s_{i}}\) potentially evaluates to 0 (in case of a completely homogeneous image). If this is the case, an arbitrary value of \(10^6\) is returned.

getContrastFeatureValue()[source]

Calculate and return the contrast.

\(Contrast = \left(\frac{1}{N_{g,p}(N_{g,p}-1)}\displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_g}_{j=1}{p_{i}p_{j}(i-j)^2}\right) \left(\frac{1}{N_p^2}\displaystyle\sum^{N_g}_{i=1}{s_i}\right)\text{, where }p_i \neq 0, p_j \neq 0\)

Contrast is a measure of the spatial intensity change, but is also dependent on the overall gray level dynamic range. Contrast is high when both the dynamic range and the spatial change rate are high, i.e. an image with a large range of gray levels, with large changes between voxels and their neighbourhood.

getBusynessFeatureValue()[source]

Calculate and return the busyness.

\(Busyness = \frac{\sum^{N_g}_{i = 1}{p_{i}s_{i}}}{\sum^{N_g}_{i = 1}\sum^{N_g}_{j = 1}{|ip_i - jp_j|}}\text{, where }p_i \neq 0, p_j \neq 0\)

A measure of the change from a pixel to its neighbour. A high value for busyness indicates a ‘busy’ image, with rapid changes of intensity between pixels and its neighbourhood.

N.B. if \(N_{g,p} = 1\), then \(busyness = \frac{0}{0}\). If this is the case, 0 is returned, as it concerns a fully homogeneous region.

getComplexityFeatureValue()[source]

Calculate and return the complexity.

\(Complexity = \frac{1}{N_p^2}\displaystyle\sum^{N_g}_{i = 1}\displaystyle\sum^{N_g}_{j = 1}{|i - j| \frac{p_{i}s_{i} + p_{j}s_{j}}{p_i + p_j}}\text{, where }p_i \neq 0, p_j \neq 0\)

An image is considered complex when there are many primitive components in the image, i.e. the image is non-uniform and there are many rapid changes in gray level intensity.

getStrengthFeatureValue()[source]

Calculate and return the strength.

\(Strength = \frac{\sum^{N_g}_{i = 1}\sum^{N_g}_{j = 1}{(p_i + p_j)(i-j)^2}}{\sum^{N_g}_{i = 1}{s_i}}\text{, where }p_i \neq 0, p_j \neq 0\)

Strenght is a measure of the primitives in an image. Its value is high when the primitives are easily defined and visible, i.e. an image with slow change in intensity but more large coarse differences in gray level intensities.

N.B. \(\sum^{N_g}_{i=1}{s_i}\) potentially evaluates to 0 (in case of a completely homogeneous image). If this is the case, 0 is returned.

Gray Level Dependence Matrix (GLDM) Features

class radiomics.gldm.RadiomicsGLDM(inputImage, inputMask, **kwargs)[source]

Bases: radiomics.base.RadiomicsFeaturesBase

A Gray Level Dependence Matrix (GLDM) quantifies gray level dependencies in an image. A gray level dependency is defined as a the number of connected voxels within distance \(\delta\) that are dependent on the center voxel. A neighbouring voxel with gray level \(j\) is considered dependent on center voxel with gray level \(i\) if \(|i-j|\le\alpha\). In a gray level dependence matrix \(\textbf{P}(i,j)\) the \((i,j)\)th element describes the number of times a voxel with gray level \(i\) with \(j\) dependent voxels in its neighbourhood appears in image.

As a two dimensional example, consider the following 5x5 image, with 5 discrete gray levels:

\[\begin{split}\textbf{I} = \begin{bmatrix} 5 & 2 & 5 & 4 & 4\\ 3 & 3 & 3 & 1 & 3\\ 2 & 1 & 1 & 1 & 3\\ 4 & 2 & 2 & 2 & 3\\ 3 & 5 & 3 & 3 & 2 \end{bmatrix}\end{split}\]

For \(\alpha=0\) and \(\delta = 1\), the GLDM then becomes:

\[\begin{split}\textbf{P} = \begin{bmatrix} 0 & 1 & 2 & 1 \\ 1 & 2 & 3 & 0 \\ 1 & 4 & 4 & 0 \\ 1 & 2 & 0 & 0 \\ 3 & 0 & 0 & 0 \end{bmatrix}\end{split}\]

Let:

  • \(N_g\) be the number of discreet intensity values in the image
  • \(N_d\) be the number of discreet dependency sizes in the image
  • \(N_z\) be the number of dependency zones in the image, which is equal to \(\sum^{N_g}_{i=1}\sum^{N_d}_{j=1}{\textbf{P}(i,j)}\)
  • \(\textbf{P}(i,j)\) be the dependence matrix
  • \(p(i,j)\) be the normalized dependence matrix, defined as \(p(i,j) = \frac{\textbf{P}(i,j)}{N_z}\)

Note

Because incomplete zones are allowed, every voxel in the ROI has a dependency zone. Therefore, \(N_z = N_p\), where \(N_p\) is the number of voxels in the image. Due to the fact that \(Nz = N_p\), the Dependence Percentage and Gray Level Non-Uniformity Normalized (GLNN) have been removed. The first because it would always compute to 1, the latter because it is mathematically equal to first order - Uniformity (see getUniformityFeatureValue()). For mathematical proofs, see here.

The following class specific settings are possible:

  • gldm_a [0]: float, \(\alpha\) cutoff value for dependence. A neighbouring voxel with gray level \(j\) is considered dependent on center voxel with gray level \(i\) if \(|i-j|\le\alpha\)
getSmallDependenceEmphasisFeatureValue()[source]

1. Small Dependence Emphasis (SDE)

\[SDE = \frac{\sum^{N_g}_{i=1}\sum^{N_d}_{j=1}{\frac{\textbf{P}(i,j)}{i^2}}}{N_z}\]

A measure of the distribution of small dependencies, with a greater value indicative of smaller dependence and less homogeneous textures.

getLargeDependenceEmphasisFeatureValue()[source]

2. Large Dependence Emphasis (LDE)

\[LDE = \frac{\sum^{N_g}_{i=1}\sum^{N_d}_{j=1}{\textbf{P}(i,j)j^2}}{N_z}\]

A measure of the distribution of large dependencies, with a greater value indicative of larger dependence and more homogeneous textures.

getGrayLevelNonUniformityFeatureValue()[source]

3. Gray Level Non-Uniformity (GLN)

..math::
GLN = frac{sum^{N_g}_{i=1}left(sum^{N_d}_{j=1}{textbf{P}(i,j)}right)^2}{N_z}

Measures the similarity of gray-level intensity values in the image, where a lower GLN value correlates with a greater similarity in intensity values.

getGrayLevelNonUniformityNormalizedFeatureValue()[source]

DEPRECATED. Gray Level Non-Uniformity Normalized (GLNN)

\(GLNN = \frac{\sum^{N_g}_{i=1}\left(\sum^{N_d}_{j=1}{\textbf{P}(i,j)}\right)^2}{\sum^{N_g}_{i=1}\sum^{N_d}_{j=1}{\textbf{P}(i,j)}^2}\)

Warning

This feature has been deprecated, as it is mathematically equal to First Order - Uniformity getUniformityFeatureValue(). See here for the proof. Enabling this feature will result in the logging of a DeprecationWarning (does not interrupt extraction of other features), no value is calculated for this features

getDependenceNonUniformityFeatureValue()[source]

4. Dependence Non-Uniformity (DN)

\[DN = \frac{\sum^{N_d}_{j=1}\left(\sum^{N_g}_{i=1}{\textbf{P}(i,j)}\right)^2}{N_z}\]

Measures the similarity of dependence throughout the image, with a lower value indicating more homogeneity among dependencies in the image.

getDependenceNonUniformityNormalizedFeatureValue()[source]

5. Dependence Non-Uniformity Normalized (DNN)

\[DNN = \frac{\sum^{N_d}_{j=1}\left(\sum^{N_g}_{i=1}{\textbf{P}(i,j)}\right)^2}{N_z^2}\]

Measures the similarity of dependence throughout the image, with a lower value indicating more homogeneity among dependencies in the image. This is the normalized version of the DLN formula.

getGrayLevelVarianceFeatureValue()[source]

6. Gray Level Variance (GLV)

\[GLV = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_d}_{j=1}{p(i,j)(i - \mu)^2} \text{, where} \mu = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_d}_{j=1}{ip(i,j)}\]

Measures the variance in grey level in the image.

getDependenceVarianceFeatureValue()[source]

7. Dependence Variance (DV)

\[DV = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_d}_{j=1}{p(i,j)(j - \mu)^2} \text{, where} \mu = \displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_d}_{j=1}{jp(i,j)}\]

Measures the variance in dependence size in the image.

getDependenceEntropyFeatureValue()[source]

8. Dependence Entropy (DE)

\[Dependence Entropy = -\displaystyle\sum^{N_g}_{i=1}\displaystyle\sum^{N_d}_{j=1}{p(i,j)\log_{2}(p(i,j)+\epsilon)}\]
getDependencePercentageFeatureValue()[source]

DEPRECATED. Dependence Percentage

\[\textit{dependence percentage} = \frac{N_z}{N_p}\]

Warning

This feature has been deprecated, as it would always compute 1. See here for more details. Enabling this feature will result in the logging of a DeprecationWarning (does not interrupt extraction of other features), no value is calculated for this features

getLowGrayLevelEmphasisFeatureValue()[source]

9. Low Gray Level Emphasis (LGLE)

\[LGLE = \frac{\sum^{N_g}_{i=1}\sum^{N_d}_{j=1}{\frac{\textbf{P}(i,j)}{i^2}}}{N_z}\]

Measures the distribution of low gray-level values, with a higher value indicating a greater concentration of low gray-level values in the image.

getHighGrayLevelEmphasisFeatureValue()[source]

10. High Gray Level Emphasis (HGLE)

\[HGLE = \frac{\sum^{N_g}_{i=1}\sum^{N_d}_{j=1}{\textbf{P}(i,j)i^2}}{N_z}\]

Measures the distribution of the higher gray-level values, with a higher value indicating a greater concentration of high gray-level values in the image.

getSmallDependenceLowGrayLevelEmphasisFeatureValue()[source]

11. Small Dependence Low Gray Level Emphasis (SDLGLE)

\[SDLGLE = \frac{\sum^{N_g}_{i=1}\sum^{N_d}_{j=1}{\frac{\textbf{P}(i,j)}{i^2j^2}}}{N_z}\]

Measures the joint distribution of small dependence with lower gray-level values.

getSmallDependenceHighGrayLevelEmphasisFeatureValue()[source]

12. Small Dependence High Gray Level Emphasis (SDHGLE)

Measures the joint distribution of small dependence with higher gray-level values.

getLargeDependenceLowGrayLevelEmphasisFeatureValue()[source]

13. Large Dependence Low Gray Level Emphasis (LDLGLE)

\[LDLGLE = \frac{\sum^{N_g}_{i=1}\sum^{N_d}_{j=1}{\frac{\textbf{P}(i,j)j^2}{i^2}}}{N_z}\]

Measures the joint distribution of large dependence with lower gray-level values.

getLargeDependenceHighGrayLevelEmphasisFeatureValue()[source]

14. Large Dependence High Gray Level Emphasis (LDHGLE)

\[LDHGLE = \frac{\sum^{N_g}_{i=1}\sum^{N_d}_{j=1}{\textbf{P}(i,j)i^2j^2}}{N_z}\]

Measures the joint distribution of large dependence with higher gray-level values.

[1]Zwanenburg, A., Leger, S., Vallières, M., and Löck, S. (2016). Image biomarker standardisation initiative - feature definitions. In eprint arXiv:1612.07003 [cs.CV]