Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 8 sur 8
  1. #1
    Modérateur
    Avatar de ToTo13
    Homme Profil pro Guillaume
    Ingénieur de Recherche
    Inscrit en
    janvier 2006
    Messages
    5 188
    Détails du profil
    Informations personnelles :
    Nom : Homme Guillaume
    Âge : 35
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur de Recherche
    Secteur : Santé

    Informations forums :
    Inscription : janvier 2006
    Messages : 5 188
    Points : 8 118
    Points
    8 118

    Par défaut [Image/Java] Gray Level Run Length Matrix

    Bonjour,

    voici deux classes permettant de calculer les Gray Level Run Length Matrix (GLRLM) ainsi que les indices associés.

    Pour ceux qui souhaiteraient utiliser ce morceaux de code, je conseille d'effacer les lignes concernant les k-means. C'était un test (relativement concluant) permettant de réduire un peu plus astucieusement les niveaux de gris.
    Mais en revanche, cela complique le code, donc à supprimer pour une ré-utilisation simple.


    Code java :
    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
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
     
    package rdf.textures.glrlm;
     
    import mathematics.Maths;
    import morphee.Levelings.Leveling;
    import processing.filters.Gaussian;
    import utils.arrays.ArraysOperations;
    import imageTiTi.Image;
    import imageTiTi.reducer.ColorReducer;
     
    /**
     * <p>Description: Cette classe calcule la "run length matrix" pour une image (vignette). Elle peut etre calculee
     *  dans plusieurs directions, mais alors une moyenne des differentes matrices est effectuee.<br>
     * <p>Package(s) required: imageTiTi, mathematics.</p>
     * <p>Copyright: Copyright (c) 2007-2010.</p>
     * <p>Laboratories/Teams: CMM (Mines-ParisTech/ENSMP), I&M (ex LXAO) LSIS.</p>
     * <p>Updates: <br>
     * 12 Avril 2010, 1.2 => Simplification par l'utilisation de l'interface ColorReducer et ajout du Leveling.<br>
     * 10 Novembre 2009, 1.1 => Gestion des tous les types de niveaux de gris, ycompris les binaires.<br>
     * 02 Mai 2008 => Ajout de la valeur interdite.<br>
     * 08 Avril 2008 => Creation.</p>
     * 
     * @author Guillaume THIBAULT
     * @version 1.2
     * <p>
     * <!-- technical-bibtex-start -->
     * BibTeX:
     * <pre>
     * &#64;article{Galloway75,
     *		author = {M. M. Galloway},
     *		journal = {Computer Graphics Image Process},
     *		volume = {4},
     *		pages = {1971--1975},
     *		title = {Texture analysis using grey level run lengths},
     *		year = {1975}
     *		}
     * </pre>
     * <pre>
     * &#64;article{CSG90,
     *		author = {A. Chu and C. M. Sehgal and J. F. Greenleaf},
     *		journal = {Pattern Recognition Letters},
     *		volume = {11},
     *		number = {6},
     *		pages = {415--420},
     *		title = {Use of gray value distribution of run lengths for texture analysis},
     *		year = {1990}
     *		}
     * </pre>
     * <pre>
     * &#64;article{PeronaMalik1990,
     *		author = {K. Yogesan and T. Jørgensen and F. Albregtsen and K. J. Tveter and H. E. Danielsen},
     *		journal = {Cytometry},
     *		volume = {24},
     *		pages = {268--276},
     *		title = {Entropy based texture analysis of chromatin structure in advanced prostate cancer},
     *		year = {1996}
     *		}
     * </pre>
     * <pre>
     * &#64;article{PeronaMalik1990,
     *		author = {Pietro Perona and Jitendra Malik},
     *		journal = {IEEE Transaction on Pattern Analysis and Machine Intelligence},
     *		volume = {12},
     *		number = {7},
     *		pages = {629-639},
     *		publisher = {Morgan Kaufmann},
     *		title = {Scale-Space and Edge Detection Using Anysotropic Diffusion},
     *		year = {1990}
     *		}
     * </pre>
     <!-- technical-bibtex-end -->
     </p>
     */
     
    public class GrayLevelRunLengthMatrix
    {
     
    /** Nombre de niveaux de gris <=> Hauteur de la run length matrix.*/
    protected int nbGrayLevel = -1 ;
    /** Largeur de la matrice. Si FixedSize Alors Width=nbSizes, Sinon Width=TailleZoneMax/nbSizes+1.*/
    protected int Width = -1 ;
    /** Tableau representant la run length matrix (a la taille de la chaine la plus longue).*/
    protected double[][] matrix = null ;
    /** Tableau representant la run length matrix brute.*/
    private double[][] mat = null ;
     
    // Les directions de calculs.
    /** La variation en X pour le calcul de la matrice.*/
    protected int[] dx = new int[] {1, 1, 0,-1} ;
    /** La variation en Y pour le calcul de la matrice.*/
    protected int[] dy = new int[] {0, 1, 1, 1} ;
     
     
    /** L'image (la vignette) sur laquelle on a calcule la matrice des longueurs de segments.*/
    protected Image image = null ;
     
    /** Un filtre gaussien, utile pour construire le marqueur du leveling.*/
    private Gaussian gauss = new Gaussian(1, 1) ;
     
     
     
     
     
     
     
    /** Un constructeur qui permet de modifier la taille de la run length matrix.
     * @param nbGrayLevel Le nombre de niveaux de gris a prendre en compte.*/
    public GrayLevelRunLengthMatrix(int nbGrayLevel)
    	{
    	if ( nbGrayLevel < 1 )
    		throw new IllegalArgumentException("Bad gray level: " + nbGrayLevel + ", wished [1..2^n < 65535]") ;
     
    	this.nbGrayLevel = nbGrayLevel ;
    	if ( nbGrayLevel == 1 ) return ; // Image binaire où l'on ne considère qu'une seule couleur.
    	if ( !Maths.isPowerOf(nbGrayLevel, 2)  )
    		throw new IllegalArgumentException("Number of gray level must be a power of 2: " + nbGrayLevel) ;
    	}
     
     
    /** Methode qui affecte la direction de calcul.
     * @param DX Deplacement en X.
     * @param DY Deplacement en Y.*/
    public void setDirection(int DX, int DY)
    	{
    	int x = DX ;
    	int y = DY ;
    	if ( x < 0 ) x = -x ;
    	if ( y < 0 ) y = -y ;
    	if ( x > 1 || y > 1 ) throw new Error("Variation de direction trop importante. Attendu [-1..1].") ;
    	if ( x + y == 0 ) throw new Error("Direction nulle : x = y = 0.") ;
    	dx = null ;
    	dy = null ;
    	dx = new int[]{DX} ;
    	dy = new int[]{DY} ;
    	}
     
     
    /** Methode qui affecte le nouveau tableau de direction. Si le tableau a une taille superieure a 1, une moyenne sera faite.
     * @param dx Nouveau tableau de variation en X.
     * @param dy Nouveau tableau de variation en Y.*/
    public void setDirection(int[] dx, int[] dy)
    	{
    	if ( dx == null || dy == null ) throw new NullPointerException("Un des tableau est null.") ;
    	if ( dx.length != dy.length )
    		throw new IllegalArgumentException("Lengths of arrays different : " + dx.length + " & " + dy.length) ;
     
    	this.dx = null ;
    	this.dy = null ;
    	this.dx = dx ;
    	this.dy = dy ;
    	}
     
     
     
    /** Methode qui lance et gere les differentes etapes de calcul.
     * @param image L'image (la vignette) sur laquelle on doit calculer la matrice.
     * @param reducer Classe qui permet de reduire le nombre de couleurs.
     * @param leveling Methode de nivellement a utiliser avant la reduction des couleurs avec un filtre gaussien comme marqueur.
     *  Si ce parametre est null, alors rien n'est realise.
     * @param ForbidenValue Valeur interdite (du fond) =>
     *  Valeur a ne pas prendre en compte pour les calculs. Si strictement negative, on prend toutes les valeurs en consideration.
     * @param nbCPU Nombre de CPU autorises dans cette classe => Nombre de threads autorises.*/
    public void FillMatrix(Image image, ColorReducer reducer, Leveling leveling, int ForbidenValue, int nbCPU)
    	{
    	if ( image.isColored() ) throw new IllegalArgumentException("Only gray level image supported.") ;
     
    	this.image = null ;
    	if ( leveling == null ) this.image = reducer.Reduce(image, nbGrayLevel, ForbidenValue) ;
    	else this.image = reducer.Reduce(leveling.Filter(image, nbCPU, gauss.Filter(image, nbCPU)), nbGrayLevel, ForbidenValue) ;
    	int x, y, i ;
    	int max = 0 ;
     
    	if ( image.getWidth() > image.getHeight() ) Width = image.getWidth() + 1 ;
    	else Width = image.getHeight() + 1 ;
     
    	mat = null ;
    	mat = new double[nbGrayLevel][Width] ;
    	ArraysOperations.SetConstant(mat, 0.0) ; // raz matrix
     
    	for (i=0 ; i < dx.length ; i++) FillMatrix(dx[i], dy[i], ForbidenValue) ;
     
    	// On trouve la largeur de la matrice.
    	for (y=0 ; y < nbGrayLevel ; y++)
    		for (x=0 ; x < Width ; x++)
    			if ( mat[y][x] > 0.0 && x > max ) max = x ;
     
    	// Moyenne
    	for (y=0 ; y < nbGrayLevel ; y++)
    		for (x=0 ; x < Width ; x++)
    			mat[y][x] /= (double)dx.length ;
     
    	// On trouve la largeur pour ajuster puis on moyenne
    	Width = max + 1 ;
    	matrix = null ;
    	matrix = new double[nbGrayLevel][Width] ;
    	for (y=0 ; y < nbGrayLevel ; y++)
    		for (x=0 ; x < Width ; x++)
    			matrix[y][x] = mat[y][x] ;
    	}
     
     
     
    /** Methode qui effectue le remplissage de la matrice Run Length.
     * @param dx Variation de calcul en X.
     * @param dy Variation de calcul en Y.
     * @param ForbidenValue Valeur a exclure des calculs.*/
    protected void FillMatrix(int dx, int dy, int ForbidenValue)
    	{
    	int x, y, x1, y1, v0, nb ;
    	int height = image.getHeight() ;
    	int width = image.getWidth() ;
    	boolean Fin ;
    	int[][] tampon = new int[mat.length][mat[0].length] ;
    	ArraysOperations.SetConstant(tampon, 0) ; // Initialisation
     
    	for (y=0 ; y < height ; y++) // calculs des run length
    		for (x=0 ; x < width ; x++)
    			{ // pour chaque pixel
    			if ( image.Pixel(y, x) == ForbidenValue ) continue ; // On est sur la valeur interdite, donc on sort.
    			v0 = image.Pixel(y, x) ;
    			nb = 1 ;
    			Fin = false ;
    			x1 = x ;
    			y1 = y ;
    			do	{
    				x1 += dx ;
    				if ( x1 < 0 || x1 >= width ) Fin = true ;
    				y1 += dy ;
    				if ( y1 < 0 || y1 >= height ) Fin = true ;
    				if ( !Fin && image.Pixel(y1, x1) != ForbidenValue && image.Pixel(y1, x1) == v0 ) nb++ ;
    				else Fin = true ;
    				} while ( !Fin ) ;
     
    			tampon[v0][nb]++ ; // on incrémente la matrice
    			}
     
    	for (y=0 ; y < nbGrayLevel ; y++) // On ajuste pour corriger les erreurs de comptages multiples.
    		for (x=1 ; x < Width ; x++)
    			tampon[y][x-1] -= tampon[y][x] ;
     
    	for (y=0 ; y < nbGrayLevel ; y++) // On met le résultat dans la matrice.
    		for (x=1 ; x < Width ; x++)
    			mat[y][x-1] += tampon[y][x] ; // On supprime la colonne 0 qui contient que des 0 (aucune chaine de longueur 0).
     
    	tampon = null ;
    	}
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
    /* ------------------------------------------------------ Les getters ------------------------------------------------------ */
    /** Methode qui retourne la run length matrix non ajustee.
     * @return Le tableau de double[][] contenant la run length matrix.*/
    public double[][] getMatrix()
    	{
    	return matrix ;
    	}
     
    /** Tableau d'int contenant les variations de directions en X.
     * @return Direction en X.*/
    public int[] getDx()
    	{
    	return dx ;
    	}
     
    /** Tableau d'int contenant les variations de directions en Y.
     * @return Direction en Y.*/
    public int[] getDy()
    	{
    	return dy ;
    	}
     
    public String toString(String Separator)
    	{
    	StringBuffer sb = new StringBuffer() ;
    	for (int j=0 ; j < nbGrayLevel ; j++)
    		{
    		for (int i=0 ; i < Width ; i++) sb.append(matrix[j][i] + Separator) ;
    		sb.append("\n") ;
    		}
    	return sb.toString() ;
    	}
     
    public void Display(String Separator)
    	{
    	System.out.println(toString(Separator)) ;
    	}
     
     
    }
    Consignes aux jeunes padawans : une image vaut 1000 mots !
    - Dans ton message respecter tu dois : les règles de rédaction et du forum, prévisualiser, relire et corriger TOUTES les FAUTES (frappes, sms, d'aurteaugrafe, mettre les ACCENTS et les BALISES) => ECRIRE clairement et en Français tu DOIS.
    - Le côté obscur je sens dans le MP => Tous tes MPs je détruirai et la réponse tu n'auras si en privé tu veux que je t'enseigne.(Lis donc ceci)
    - ton poste tu dois marquer quand la bonne réponse tu as obtenu.

  2. #2
    Modérateur
    Avatar de ToTo13
    Homme Profil pro Guillaume
    Ingénieur de Recherche
    Inscrit en
    janvier 2006
    Messages
    5 188
    Détails du profil
    Informations personnelles :
    Nom : Homme Guillaume
    Âge : 35
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur de Recherche
    Secteur : Santé

    Informations forums :
    Inscription : janvier 2006
    Messages : 5 188
    Points : 8 118
    Points
    8 118

    Par défaut

    Le calcul des indices est réalisé par la classe suivante.
    Les indices VAR1 et VAR2 sont de ma conception et ont été présentés dans
    @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)},
    Keywords = {Texture features, Texture indexes, Classification, Cell Nuclei, Run length matrix (GLRLM), Size Zone Matrix (GLSZM), WND-CHARM, Homogeneous Texture},
    Month = {May},
    Pages = {140-145},
    Title = {Texture Indexes and Gray Level Size Zone Matrix Application to Cell Nuclei Classification},
    Year = {2009}}
    Il y a également le calcul des caractéristiques Haralick sur ces matrices, mais cela donne RAREMENT de bons résultats.

    Code java :
    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
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
     
    package rdf.textures.glrlm;
     
    import imageTiTi.Image;
    import imageTiTi.reducer.ColorReducer;
     
    import morphee.Levelings.Leveling;
    import rdf.Features;
     
    /**
     * <p>Description: Cette classe calcule les caracteristiques de la "run length matrix" pour une image (vignette).
     * Elles peuvent etre calculees dans plusieurs directions, mais alors une moyenne est faite.<br>
     * Liste des caracteristiques calculees :<br>
     *  - F0 => Short Run Emphasis, SRE.<br>
     *  - F1 => Long Run Emphasis, LRE.<br>
     *  - F2 => Gray Level Non Uniformity, GLNU.<br>
     *  - F3 => Run Length Non Uniformity, RLNU.<br>
     *  - F4 => Run Percentage, RP.<br>
     *  - F5 => Low Gray Level Run Emphasis, LGLRE.<br>
     *  - F6 => High Gray Level Run Emphasis, HGLRE.<br>
     *  - F7 => Short Run Low Gray Level Emphasis, SRLGLE.<br>
     *  - F8 => Short Run High Gray Level Emphasis, SRHGLE.<br>
     *  - F9 => Long Run Low Gray Level Emphasis, LRLGLE.<br>
     *  - F10 => Long Run High Gray Level Emphasis, LRHGLE.<br>
     *  - VAR1 => Variance ponderee sur les niveaux de gris.<br>
     *  - VAR2 => Variance ponderee sur longueurs des segments.</p>
     * <p>Package(s) required: imageTiTi, morphee.</p>
     * <p>Copyright: Copyright (c) 2007-2010.</p>
     * <p>Laboratories/Teams: CMM (Mines-ParisTech/ENSMP), I&M (ex LXAO) LSIS.</p>
     * <p>Updates: <br>
     * 07 Fevrier 2010 => Suppression des caracteristiques Haralick.<br>
     * 19 Novembre 2009 => Ajout de la methode ComputeFromStack qui permet de faire les calculs sur une pile d'images
     *  (projet Loreal, CMM ENSMP).<br>
     * 08 Avril 2008 => Creation.</p>
     * 
     <!-- technical-bibtex-start -->
     * BibTeX:
     * <pre>
     * &#64;article{YJATD96,
     *    author = {K. Yogesan and T. Jørgensen and F. Albregtsen and K. J. Tveter and H. E. Danielsen},
     *    journal = {Cytometry},
     *    pages = {268-276},
     *    title = {Entropy based texture analysis of chromatin structure in advanced prostate cancer},
     *    volume = {24},
     *    year = {1996}
     * }
     * 
     * &#64;article{KMGK99,
     *    author = {S. A. Karkanis and George D. Magoulas and Maria Grigoriadou and Dimitris A. Karras},
     *    journal = {EUROMICRO},
     *    pages = {392-396},
     *    title = {Neural Network based textural labeling of images in multimedia applications},
     *    volume = {2},
     *    year = {1999}
     * }
     * 
     * &#64;conference{XKFR04,
     *    author = {D. H. Xu and A.S. Kurani and J.D. Furst and D.S. Raicu},
     *    Booktitle = {International Conference on Visualization, Imaging, and Image Processing (VIIP)},
     *    pages = {452-458},
     *    title = {Run-Length Encoding For Volumetric Texture},
     *    year = {2004}
     * }
     * </pre>
     * <p/>
     <!-- technical-bibtex-end -->
     *
     *
     * @author Guillaume THIBAULT
     * @version 1.0
     */
     
    public class GlrlmFeatures extends GrayLevelRunLengthMatrix implements Features
    {
     
    /** Tableau qui va contenir toutes les caracteristiques.*/
    private double[] Features = new double[13] ;
    /** Variable qui va etre egale a la somme de tous les elements de la matrice.*/
    private double Sum = 0.0 ;
     
    /** Tableau contenant les noms des caracteristiques Haralick qui sont calculees.*/
    private String[] FeaturesNames = new String[]{"SRE", "LRE", "GLNU", "RLNU", "RP", "LGLRE", "HGLRE",
    											"SRLGLE", "SRHLGE", "LRLGLE", "LRHGLE", "VAR1", "VAR2" } ;
     
     
    /** Un constructeur qui permet de modifier la taille de la run length matrix.
     * @param nbGrayLevel Le nombre de niveaux de gris a prendre en compte, ce sera la hauteur de la matrice.*/
    public GlrlmFeatures(int nbGrayLevel)
    	{
    	super(nbGrayLevel) ;
    	}
     
     
     
     
    /** Methode qui lance et gere les differentes etapes de calcul. Inutile d'appeler la methode "FillMatrix".
     * @param image L'image a caracteriser
     * @param reducer Classe qui permet de reduire le nombre de couleurs.
     * @param leveling Methode de nivellement a utiliser avant la reduction des couleurs avec un filtre gaussien comme marqueur.
     *  Si ce parametre est null, alors rien n'est realise.
     * @param ForbidenValue La valeur a exclure lors de calculs. Mettre -1 si toute la texture est a caracteriser.
     * @param nbCPU Nombre de CPU autorises dans cette classe => Nombre de threads autorises.*/
    public void Compute(Image image, ColorReducer reducer, Leveling leveling, int ForbidenValue, int nbCPU)
    	{
    	if ( image.isColored() ) throw new IllegalArgumentException("Only gray level or binary images supported.") ;
     
    	FillMatrix(image, reducer, leveling, ForbidenValue, nbCPU) ; // On remplit la matrice :)
     
    	ComputeFeatures() ;
    	}
     
     
     
    /** Methode qui gere le calcul des indices de texture.*/
    private void ComputeFeatures()
    	{
    	Sum = 0.0 ;
    	for (int y=0 ; y < nbGrayLevel ; y++)
    		for (int x=0 ; x < Width ; x++)
    			Sum += matrix[y][x] ;
     
    	Features[0] = SRE() ;
    	Features[1] = LRE() ;
    	Features[2] = GLNU() ;
    	Features[3] = RLNU() ;
    	Features[4] = RP() ;
    	Features[5] = LGLRE() ;
    	Features[6] = HGLRE() ;
    	Features[7] = SRLGLE() ;
    	Features[8] = SRHGLE() ;
    	Features[9] = LRLGLE() ;
    	Features[10] = LRHGLE() ;
    	Features[11] = VAR1() ;
    	Features[12] = VAR2() ;
    	}
     
     
     
     
    /** Methode qui lance et gere les differentes etapes de calcul pour un tas (pile) d'images.
     * @param images Les vignettes (images) contenant les texture a caracteriser.
     * @param reducer Classe qui permet de reduire le nombre de couleurs.
     * @param leveling Methode de nivellement a utiliser avant la reduction des couleurs avec un filtre gaussien comme marqueur.
     *  Si ce parametre est null, alors rien n'est realise.
     * @param ForbidenValue La valeur a exclure lors de calculs. Mettre -1 si toute la texture est a caracteriser.
     * @param nbCPU Nombre de CPU autorises dans cette classe => Nombre de threads autorises.*/
    public void ComputeFromStack(Image[] images, ColorReducer reducer, Leveling leveling, int ForbidenValue, int nbCPU)
    	{
    	int i, j ;
    	int[] nbNanF1 = new int[Features.length] ;
    	double[] F1 = new double[Features.length] ; // Tableaux temporaires contenant la somme des caractéristiques.
     
    	for (i=0 ; i < images.length ; i++)
    		{
    		Compute(images[i], reducer, leveling, ForbidenValue, nbCPU) ; // On calcul les caractéristiques
     
    		for (j=0 ; j < F1.length ; j++)
    			if ( Double.isNaN(Features[j])) nbNanF1[j]++ ; // On compte le nombre de Nan pour ajuster les calculs.
    			else F1[j] += Features[j] ; // On sauvegarde les résultats.
    		}
     
    	for (j=0 ; j < F1.length ; j++) Features[j] = F1[j] / (double)(images.length-nbNanF1[j]) ;
    	F1 = null ;
    	nbNanF1 = null ;
    	}
     
     
     
     
     
     
     
     
     
     
     
     
     
     
    /* ------------------------------------------------- Calcul des caractéristiques ------------------------------------------------- */
    /** F0 - Short Run Emphasis, SRE. Courte isolongueur.
     * @return SRE.*/
    private double SRE()
    	{
    	int n, l ;
    	double val = 0.0 ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			val += matrix[n][l] / Math.pow(l+1, 2.0) ;
    	return val /(double)Sum ;
    	}
     
    /** F1 - Long Run Emphasis, LRE. Grande isolongueur.
     * @return LRE.*/
    private double LRE()
    	{
    	int n, l ;
    	double val = 0.0 ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			val += matrix[n][l] * Math.pow(l+1, 2.0) ;
    	return val / Sum ;
    	}
     
    /** F2 - Gray Level Non Uniform, GLNU. Homogeneite spectrale.
     * @return GLNU.*/
    private double GLNU()
    	{
    	int n, l ;
    	double v, val = 0.0 ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		{
    		v = 0.0 ;
    		for (l=0 ; l < Width ; l++)
    			v += matrix[n][l] ;
    		val += v*v ;
    		}
    	return val / (double)Sum ;
    	}
     
    /** F3 - Run Length Non Uniform, RLNU. Uniformite.
     * @return RLNU.*/
    private double RLNU()
    	{
    	int n, l ;
    	double v, val = 0.0 ;
    	for (l=0 ; l < Width ; l++)
    		{
    		v = 0.0 ;
    		for (n=0 ; n < nbGrayLevel ; n++)
    			v += matrix[n][l] ;
    		val += v*v ;
    		}
    	return val / Sum ;
    	}
     
    /** F4 - Run Percentage, RP. Egalite des isolongueur (pourcentage primitives).
     * @return RP.*/
    private double RP()
    	{
    	int n, l ;
    	double val = 0.0 ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			val += (double)(l+1) * matrix[n][l] ;
    	return Sum / val ;
    	}
     
    /** F5 - Low Gray Level Run Emphasis, LGLRE.
     * @return LGLRE.*/
    private double LGLRE()
    	{
    	int n, l ;
    	double val = 0.0 ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			val += matrix[n][l] / Math.pow(n+1, 2.0) ;
    	return val / Sum ;
    	}
     
    /** F6 - High Gray Level Run Emphasis, HGLRE.
     * @return LGLRE.*/
    private double HGLRE()
    	{
    	int n, l ;
    	double val = 0.0 ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			val += matrix[n][l] * Math.pow(n+1, 2.0) ;
    	return val / Sum ;
    	}
     
    /** F7 - Short Run Low Gray Level Emphasis, SRLGLE.
     * @return SRLGLE.*/
    private double SRLGLE()
    	{
    	int n, l ;
    	double val = 0.0 ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			val += matrix[n][l] / (Math.pow(n+1, 2.0) * Math.pow(l+1, 2.0)) ;
    	return val / Sum ;
    	}
     
    /** F8 - Short Run High Gray Level Emphasis, SRHGLE.
     * @return SRHGLE.*/
    private double SRHGLE()
    	{
    	int n, l ;
    	double val = 0.0 ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			val += matrix[n][l] * Math.pow((double)(n+1)/(double)(l+1), 2.0) ;
    	return val / Sum ;
    	}
     
    /** F9 - Long Run Low Gray Level Emphasis, LRLGLE.
     * @return LRLGLE.*/
    private double LRLGLE()
    	{
    	int n, l ;
    	double val = 0.0 ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			val += matrix[n][l] * Math.pow((double)(l+1)/(double)(n+1), 2.0) ;
    	return val / Sum ;
    	}
     
    /** F10 - Long Run High Gray Level Emphasis, LRHGLE.
     * @return LRHGLE.*/
    private double LRHGLE()
    	{
    	int n, l ;
    	double val = 0.0 ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			val += matrix[n][l] * Math.pow(n+1, 2.0) * Math.pow(l+1, 2.0) ;
    	return val / Sum ;
    	}
     
    /** Methode qui calcule la variance sur les niveaux de gris.
     * @return La variance sur les niveaux de gris.*/
    private double VAR1()
    	{
    	int n, l ;
    	double mean = 0.0 ;
    	double val = 0.0 ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			mean += (double)n * matrix[n][l] ;
    	mean /= Sum ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			val += Math.pow((double)n * matrix[n][l] - mean, 2.0) ;
    	return Math.sqrt(val / Sum) ;
    	}
     
    /** Methode qui calcule la variance sur les tailles.
     * @return La variance sur les tailles.*/
    private double VAR2()
    	{
    	int n, l ;
    	double mean = 0.0 ;
    	double val = 0.0 ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			mean += (double)l * matrix[n][l] ;
    	mean /= Sum ;
    	for (n=0 ; n < nbGrayLevel ; n++)
    		for (l=0 ; l < Width ; l++)
    			val += Math.pow((double)l * matrix[n][l] - mean, 2.0) ;
    	return Math.sqrt(val / Sum) ;
    	}
     
     
     
     
     
     
     
     
     
     
     
     
     
    /* ---------------------------------------------------- Les getters ---------------------------------------------------- */
    /** Methode qui retourne la liste des caracteristiques.
     * @return Le tableau de double contenant les caracteristiques.*/
    public double[] Feature()
    	{
    	return Features ;
    	}
     
    /** Methode qui retourne une des caracteristiques.
     * @param i Le numero de la caracteristique.
     * @return La valeur de type double de la caracteristiques.*/
    public double Feature(int i)
    	{
    	if ( i < 0 || i >= Features.length )
    		throw new Error("Numéro de RLM's Features incorrect : " + i + ", attendu [0.." + (Features.length-1) + "].") ;
    	return Features[i] ;
    	}
     
    /** Methode qui renvoit un tableau contenant les noms des caracteristiques.
     * @return Le tableau de string contenant les noms.*/
    public String[] FeaturesNames()
    	{
    	return FeaturesNames ;
    	}
     
    }
    Consignes aux jeunes padawans : une image vaut 1000 mots !
    - Dans ton message respecter tu dois : les règles de rédaction et du forum, prévisualiser, relire et corriger TOUTES les FAUTES (frappes, sms, d'aurteaugrafe, mettre les ACCENTS et les BALISES) => ECRIRE clairement et en Français tu DOIS.
    - Le côté obscur je sens dans le MP => Tous tes MPs je détruirai et la réponse tu n'auras si en privé tu veux que je t'enseigne.(Lis donc ceci)
    - ton poste tu dois marquer quand la bonne réponse tu as obtenu.

  3. #3
    Modérateur
    Avatar de ToTo13
    Homme Profil pro Guillaume
    Ingénieur de Recherche
    Inscrit en
    janvier 2006
    Messages
    5 188
    Détails du profil
    Informations personnelles :
    Nom : Homme Guillaume
    Âge : 35
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur de Recherche
    Secteur : Santé

    Informations forums :
    Inscription : janvier 2006
    Messages : 5 188
    Points : 8 118
    Points
    8 118

    Par défaut

    Voici un exemple d'utilisation de ce morceau de code :
    Code java :
    1
    2
    3
    4
    5
    6
     
    int nbCPU = 2 ; // Le nombre de CPU que vous souhaitez allouer à ce calcul.
    ColorReducer glr = new GrayLevelReducer() ; // Voir ici : http://www.developpez.net/forums/d911116/autres-langages/algorithmes/contribuez/image-java-reduction-nombre-niveaux-gris/
    GlrlmFeatures glrlm = new GlrlmFeatures(32) ; // On spécifie le nombre de niveaux de gris a utiliser lors de l'instanciation.
    glrlm.Compute(ImageCourante, glr, null, -1, nbCPU) ; // -1 veut dire que tous les pixels de l'image sont pris en compte, sinon mettre la valeur interdite.
    double[] resultat = glrlm.getFeatures() ;

    Dans la méthode Compute, on peut spécifier une couleur a ne pas prendre en compte. Par exemple, s'il s'agit d'une forme segmentée sur un fond noir, alors il faut mettre 0.
    Utiliser une valeur négative permet de prendre en compte TOUTE la texture.
    Consignes aux jeunes padawans : une image vaut 1000 mots !
    - Dans ton message respecter tu dois : les règles de rédaction et du forum, prévisualiser, relire et corriger TOUTES les FAUTES (frappes, sms, d'aurteaugrafe, mettre les ACCENTS et les BALISES) => ECRIRE clairement et en Français tu DOIS.
    - Le côté obscur je sens dans le MP => Tous tes MPs je détruirai et la réponse tu n'auras si en privé tu veux que je t'enseigne.(Lis donc ceci)
    - ton poste tu dois marquer quand la bonne réponse tu as obtenu.

  4. #4
    Modérateur
    Avatar de ToTo13
    Homme Profil pro Guillaume
    Ingénieur de Recherche
    Inscrit en
    janvier 2006
    Messages
    5 188
    Détails du profil
    Informations personnelles :
    Nom : Homme Guillaume
    Âge : 35
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur de Recherche
    Secteur : Santé

    Informations forums :
    Inscription : janvier 2006
    Messages : 5 188
    Points : 8 118
    Points
    8 118

    Par défaut

    Bonjour,

    il semblerait que j'avais oublié de mettre à jour cette version des "Run Length Matrix". Et bien voilà qui est fait.
    C'est une version plus simple au niveau utilisation/compréhension. J'ai essentiellement externalisé la réduction des niveaux de gris, ajouté la possibilité d'utiliser préalablement des levelings sur l'image à traiter et supprimé les caractéristiques Haralick des caractéristiques car cela ne m'a jamais rien apporté de plus que les moments (d'ordre -2 à 2) déjà disponibles.
    Consignes aux jeunes padawans : une image vaut 1000 mots !
    - Dans ton message respecter tu dois : les règles de rédaction et du forum, prévisualiser, relire et corriger TOUTES les FAUTES (frappes, sms, d'aurteaugrafe, mettre les ACCENTS et les BALISES) => ECRIRE clairement et en Français tu DOIS.
    - Le côté obscur je sens dans le MP => Tous tes MPs je détruirai et la réponse tu n'auras si en privé tu veux que je t'enseigne.(Lis donc ceci)
    - ton poste tu dois marquer quand la bonne réponse tu as obtenu.

  5. #5
    Membre régulier
    Profil pro
    Inscrit en
    décembre 2007
    Messages
    124
    Détails du profil
    Informations personnelles :
    Âge : 29
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations forums :
    Inscription : décembre 2007
    Messages : 124
    Points : 76
    Points
    76

    Par défaut

    Super
    Et plus ca marche plutot pas mal... jvais tester de ce pas les GLSZM du coup
    Merci !

  6. #6
    Modérateur
    Avatar de ToTo13
    Homme Profil pro Guillaume
    Ingénieur de Recherche
    Inscrit en
    janvier 2006
    Messages
    5 188
    Détails du profil
    Informations personnelles :
    Nom : Homme Guillaume
    Âge : 35
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur de Recherche
    Secteur : Santé

    Informations forums :
    Inscription : janvier 2006
    Messages : 5 188
    Points : 8 118
    Points
    8 118

    Par défaut

    Citation Envoyé par Mr.ux Voir le message
    jvais tester de ce pas les GLSZM du coup
    Pour quel type d'application ?
    Consignes aux jeunes padawans : une image vaut 1000 mots !
    - Dans ton message respecter tu dois : les règles de rédaction et du forum, prévisualiser, relire et corriger TOUTES les FAUTES (frappes, sms, d'aurteaugrafe, mettre les ACCENTS et les BALISES) => ECRIRE clairement et en Français tu DOIS.
    - Le côté obscur je sens dans le MP => Tous tes MPs je détruirai et la réponse tu n'auras si en privé tu veux que je t'enseigne.(Lis donc ceci)
    - ton poste tu dois marquer quand la bonne réponse tu as obtenu.

  7. #7
    Membre régulier
    Profil pro
    Inscrit en
    décembre 2007
    Messages
    124
    Détails du profil
    Informations personnelles :
    Âge : 29
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations forums :
    Inscription : décembre 2007
    Messages : 124
    Points : 76
    Points
    76

    Par défaut

    Citation Envoyé par ToTo13 Voir le message
    Pour quel type d'application ?
    Pour l'instant, sur des textures "théoriques" provenant des bases de Brodatz, Vistex etc... J'envisage de tester/appliquer à des images satelites.

  8. #8
    Modérateur
    Avatar de ToTo13
    Homme Profil pro Guillaume
    Ingénieur de Recherche
    Inscrit en
    janvier 2006
    Messages
    5 188
    Détails du profil
    Informations personnelles :
    Nom : Homme Guillaume
    Âge : 35
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur de Recherche
    Secteur : Santé

    Informations forums :
    Inscription : janvier 2006
    Messages : 5 188
    Points : 8 118
    Points
    8 118

    Par défaut

    Bonjour,

    alors pour Brodatz, j'avais fait des tests et c'est bien les GLRLM qui fonctionnent le mieux et de loin.
    Les GLSZM sont très efficaces pour tout ce qui est homogénéité de la texture ou longueur de filaments/zones.
    On s'apprête à publier deux nouveaux types de matrices, dont je posterai le code dès que les articles seront acceptés.
    Consignes aux jeunes padawans : une image vaut 1000 mots !
    - Dans ton message respecter tu dois : les règles de rédaction et du forum, prévisualiser, relire et corriger TOUTES les FAUTES (frappes, sms, d'aurteaugrafe, mettre les ACCENTS et les BALISES) => ECRIRE clairement et en Français tu DOIS.
    - Le côté obscur je sens dans le MP => Tous tes MPs je détruirai et la réponse tu n'auras si en privé tu veux que je t'enseigne.(Lis donc ceci)
    - ton poste tu dois marquer quand la bonne réponse tu as obtenu.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •