Description: This class fills a "Size Zone Matrix".
*Package(s) required: dv, imageTiTi, mathematics, measures, morphee, processing.
*Copyright: Copyright (c) 2006-Today.
*Updates:
* February 27 2011 => Add methods required for interfaces Computable and PreComputable (for class GlszmFeatures).
* 11 Avril 2010, 1.3 => Gestion de la reduction des tailles pour le stockage dans la matrice.
*
* * BibTeX: *
* @conference{Thibault09,
* address = {Minsk, Belarus},
* author = {Guillaume Thibault and Bernard Fertil and Claire Navarro and Sandrine Pereira and Pierre Cau
* and Nicolas Levy and Jean Sequeira and Jean-Luc Mari},
* booktitle = {Pattern Recognition and Information Processing (PRIP)},
* pages = {140--145},
* title = {Texture Indexes and Gray Level Size Zone Matrix. Application to Cell Nuclei Classification},
* year = {2009}
* }
*
*
* @conference{ThibaultICIP11,
* address = {Brussel, Belgium},
* author = {Guillaume Thibault and Jesus Angulo and Fernand Meyer},
* booktitle = {IEEE International Conference on Image Processing (ICIP)},
* pages = {53--56},
* title = {Advanced Statistical Matrices for Texture Characterization:
* Application to DNA Chromatin and Microtubule Network Classification},
* year = {2011}
* }
*
*
*
*/
public class GrayLevelSizeZoneMatrix
{
/** Matrix height <=> Number of gray level.*/
protected int nbGrayLevel = -1 ;
/** Number of size of zones to consider. If FixedSize=true it will be the matrix width, else it is the step.*/
protected int nbSizes = -1 ;
/** Matrix width. If FixedSize then Width=nbSizes, else Width=SizeZoneMax/nbSizes+1.*/
protected int Width = -1 ;
/** Is the width fixed? */
protected boolean FixedSize = false ;
/** The array which represents the size zone matrix.*/
protected double[][] matrix = null ;
/** The original image after color reduction.*/
protected BufferedImage Reduced = null ;
/** The original volume after color reduction.*/
protected DV Reduced3D = null ;
/** This class realizes the labeling of connected components.*/
protected ConnectedComponentLabeling ccl = new UnionFindCcl() ;
/** A gaussian filter, usefull to computes the marker of leveling.*/
private Gaussian gauss = new Gaussian(1, 1) ;
/** The color reducer to use.*/
protected ColorReducer reducer = null ;
/** The leveling to use.*/
protected Leveling leveling = null ;
/** The forbidden value during processing.*/
protected int ForbiddenValue = -1 ;
/** Is the 8-connexty used?*/
protected boolean EightConnex = true ;
/** The number of thread to use.*/
protected int nbCPU = -1 ;
public GrayLevelSizeZoneMatrix()
{
}
/** This method realizes the processing.
* @param image The image to characterize.
* @param nbGrayLevel The number of gray level after reduction (matrix height).
* @param nbSizes Number of size of zones. If FixedSize=true it will be the matrix width, else it will be the step.
* @param FixedSize Is the width fixed?
* @param reducer This class reduce the number of gray level.
* @param leveling The leveling to use before the color reduction. If null, any leveling realized.
* @param ForbiddenValue The backgorund value or value to not take into account during processing. If negative, so the entire
* texture is processed.
* @param EightConnex Use 8-connexity for labeling?
* @param nbCPU Number of thread to use for processing.*/
public void FillMatrix(BufferedImage image, int nbGrayLevel, int nbSizes, boolean FixedSize, ColorReducer reducer,
Leveling leveling, int ForbiddenValue, boolean EightConnex, int nbCPU)
{
if ( !ImageTools.isGrayLevel(image) ) throw new IllegalArgumentException("Only gray level images supported.") ;
if ( nbGrayLevel < 2 )
throw new IllegalArgumentException("Number of gray level incorrect: " + nbGrayLevel + ", wish [2...2^N[") ;
this.nbGrayLevel = nbGrayLevel ;
this.nbSizes = nbSizes ;
this.FixedSize = FixedSize ;
this.reducer = reducer ;
this.leveling = leveling ;
this.ForbiddenValue = ForbiddenValue ;
this.EightConnex = EightConnex ;
this.nbCPU = nbCPU ;
if ( !Maths.isPowerOf(nbGrayLevel, 2) )
throw new IllegalArgumentException("Number of gray level must be a power of 2: " + nbGrayLevel) ;
if ( FixedSize && ( matrix == null || matrix.length != nbGrayLevel || matrix[0].length != Width) )
{
Width = nbSizes ;
matrix = new double[nbGrayLevel][Width] ;
}
int i, width ;
Reduced = null ;
if ( leveling == null ) Reduced = reducer.Reduce(image, nbGrayLevel, ForbiddenValue) ;
else Reduced = reducer.Reduce(leveling.Filter(image, nbCPU, gauss.Filter(image, nbCPU)), nbGrayLevel, ForbiddenValue) ;
ccl.Label(Reduced, 0, EightConnex) ; // On calcule (Žtiquette) les composantes connexes.
int[][] Labels = ccl.Labels() ;
int[] Sizes = ccl.Sizes() ; // On rŽcupre la dimension de chaque composante.
int[] Correspondances = new int[Sizes.length] ;
FindValues(Labels, Correspondances) ; // Correspondance composante/niveau de gris. La case 0 = ForbiddenValue
width = 0 ;
for (i=1 ; i < Sizes.length ; i++) // On trouve la taille de la plus grande zone.
if ( Correspondances[i] >= 0 && width < Sizes[i] )
width = Sizes[i] ;
if ( FixedSize )
{
ArrayOperations.Fill(matrix, 0.0) ; // Matrice dŽjˆ allouŽe, donc il suffit de la re-initialiser.
for (i=1 ; i < Correspondances.length ; i++) // On remplit la matrice
if ( Correspondances[i] >= 0 )
matrix[Correspondances[i]][(int)((double)(Sizes[i]-1)/(double)width*(double)nbSizes)]++ ;
}
else
{
Width = width/nbSizes+1 ;
matrix = null ;
matrix = new double[nbGrayLevel][Width] ;
for (i=1 ; i < Correspondances.length ; i++) // On remplit la matrice
if ( Correspondances[i] >= 0 )
matrix[Correspondances[i]][Sizes[i]/nbSizes]++ ;
}
}
/** This method realizes the processing.
* @param ImageReduced The original image after color reduction.
* @param Ccl The class which realizes labeling of connected components.*/
public void FillMatrix(BufferedImage ImageReduced, ConnectedComponentLabeling Ccl)
{
if ( !ImageTools.isGrayLevel(ImageReduced) ) throw new IllegalArgumentException("Only gray level images supported.") ;
int i, width ;
int[][] Labels = Ccl.Labels() ;
int[] Sizes = Ccl.Sizes() ;
int[] Correspondances = new int[Sizes.length] ;
FindValues(Labels, Correspondances) ; // Correspondance composante/niveau de gris. La case 0 = ForbiddenValue
width = 0 ;
for (i=1 ; i < Sizes.length ; i++) // On trouve la taille max des composantes qui sera la largeur de la matrice.
if ( Correspondances[i] >= 0 && width < Sizes[i] )
width = Sizes[i] ;
if ( FixedSize )
{
ArrayOperations.Fill(matrix, 0.0) ; // Matrice dŽjˆ allouŽe, donc il suffit de la re-initialiser.
for (i=1 ; i < Correspondances.length ; i++) // On remplit la matrice
if ( Correspondances[i] >= 0 )
matrix[Correspondances[i]][(int)((double)(Sizes[i]-1)/(double)width*(double)nbSizes)]++ ;
}
else
{
Width = width/nbSizes+1 ;
matrix = null ;
matrix = new double[nbGrayLevel][Width] ;
for (i=1 ; i < Correspondances.length ; i++) // On remplit la matrice
if ( Correspondances[i] >= 0 )
matrix[Correspondances[i]][Sizes[i]/nbSizes]++ ;
}
}
/** This method realizes the processing in case of pre-computations.
* @param sizes The array which contains all size zones.
* @param colors The array which contains all color zones.
* @param used The array which determines if a zone is used during processing (matrix filling).
* @param nbCPU Number of thread to use for processing.*/
public void FillMatrix(int[] sizes, int[] colors, boolean[] used, int nbCPU)
{
int i, Largeur = 0 ;
for (i=1 ; i < sizes.length ; i++)
if ( used[i] && Largeur < sizes[i] )
Largeur = sizes[i] ;
if ( FixedSize )
{
ArrayOperations.Fill(matrix, 0.0) ; // Matrice dŽjˆ allouŽe, donc il suffit de la re-initialiser.
for (i=1 ; i < sizes.length ; i++) // On remplit la matrice
if ( used[i] )
matrix[colors[i]-1][(int)((double)(sizes[i]-1)/(double)Largeur*(double)nbSizes)]++ ;
}
else
{
Width = Largeur/nbSizes + 1 ;
matrix = null ;
matrix = new double[nbGrayLevel][Width] ;
for (i=1 ; i < sizes.length ; i++) // On remplit la matrice
if ( used[i] )
try {
matrix[colors[i]-1][sizes[i]/nbSizes]++ ;
}
catch ( Exception E )
{
System.err.println(i + " => " + colors[i] + " => " + sizes[i]) ;
}
}
}
/** This method realizes the processing.
* @param list The list of reduced images: one zone per image!
* @param nbCPU Number of thread to use for processing.*/
public void FillMatrix(List