TEXTURE * Extract_Texture_Features(int distance, register gray **grays, int rows, int cols, TEXTURE_FEATURE_MAP *feature_usage)
{
FILE *ifp;
register gray *gP;
int tone[PGM_MAXMAXVAL+1], R0, R45, R90, R135, angle, d = 1, x, y;
int argn, bps, padright, row, col, i;
int itone, jtone, tones,g_val;
float **P_matrix0, **P_matrix45, **P_matrix90, **P_matrix135;
float ASM[4], contrast[4], corr[4], var[4], idm[4], savg[4];
float sentropy[4], svar[4], entropy[4], dvar[4], dentropy[4];
float icorr[4], maxcorr[4];
float *Tp;
gray nmaxval, maxval;
char *usage = "[-d <d>] [pgmfile]";
TEXTURE *Texture;
Texture = (TEXTURE *) calloc(1,sizeof(TEXTURE));
if(!Texture) {
printf("\nERROR in TEXTURE structure allocate\n");
exit(1);
}
d = distance;
/* Determine the number of different gray scales (not maxval) */
for (row = PGM_MAXMAXVAL; row >= 0; --row)
tone[row] = -1;
for (row = rows - 1; row >= 0; --row)
for (col = 0; col < cols; ++col)
{
/* if (grays[row][col]) If gray value equal 0 don't include */
tone[grays[row][col]] = grays[row][col];
}
for (row = PGM_MAXMAXVAL, tones = 0; row >= 0; --row)
if (tone[row] != -1)
tones++;
/* fprintf (stderr, "(Image has %d graylevels.)\n", tones); */
/* Collapse array, taking out all zero values */
for (row = 0, itone = 0; row <= PGM_MAXMAXVAL; row++)
if (tone[row] != -1)
tone[itone++] = tone[row];
/* Now array contains only the gray levels present (in ascending order) */
/* Allocate memory for gray-tone spatial dependence matrix */
P_matrix0 = pgm_matrix (0, tones, 0, tones);
P_matrix45 = pgm_matrix (0, tones, 0, tones);
P_matrix90 = pgm_matrix (0, tones, 0, tones);
P_matrix135 = pgm_matrix (0, tones, 0, tones);
for (row = 0; row < tones; ++row)
for (col = 0; col < tones; ++col)
{
P_matrix0[row][col] = P_matrix45[row][col] = 0;
P_matrix90[row][col] = P_matrix135[row][col] = 0;
}
R0 = 0;
R45 = 0;
R90 = 0;
R135 = 0;
/* Find gray-tone spatial dependence matrix */
/* fprintf (stderr, "(Computing spatial dependence matrix..."); */
for (row = 0; row < rows; ++row)
for (col = 0; col < cols; ++col)
/* if (grays[row][col]) */
for (x = 0, angle = 0; angle <= 135; angle += 45)
{
while (tone[x] != grays[row][col])
x++;
/* M. Boland if (angle == 0 && col + d < cols) */
/* M. Boland - include neighbor only if != 0 */
if (angle == 0 && col + d < cols && grays[row][col + d])
{
y = 0;
while (tone[y] != grays[row][col + d])
y++;
P_matrix0[x][y]++;
P_matrix0[y][x]++;
/* R0++; M. Boland 25 Nov 98 */
R0+=2 ;
}
/* M. Boland if (angle == 90 && row + d < rows) */
/* M. Boland - include neighbor only if != 0 */
else if (angle == 90 && row + d < rows && grays[row + d][col])
{
y = 0;
while (tone[y] != grays[row + d][col])
y++;
P_matrix90[x][y]++;
P_matrix90[y][x]++;
/* R90++; M. Boland 25 Nov 98 */
R90+=2 ;
}
/* M. Boland if (angle == 45 && row + d < rows && col - d >= 0) */
/* M. Boland - include neighbor only if != 0 */
else if (angle == 45 && row + d < rows && col - d >= 0
&& grays[row + d][col - d])
{
y = 0;
while (tone[y] != grays[row + d][col - d])
y++;
P_matrix45[x][y]++;
P_matrix45[y][x]++;
/* R45++; M. Boland 25 Nov 98 */
R45+=2 ;
}
/* M. Boland if (angle == 135 && row + d < rows && col + d < cols) */
else if (angle == 135 && row + d < rows && col + d < cols
&& grays[row + d][col + d])
{
y = 0;
while (tone[y] != grays[row + d][col + d])
y++;
P_matrix135[x][y]++;
P_matrix135[y][x]++;
/* R135++; M. Boland 25 Nov 98 */
R135+=2 ;
}
}
/* Gray-tone spatial dependence matrices are complete */
/* Find normalizing constants */
/* R0 = 2 * rows * (cols - 1);
R45 = 2 * (rows - 1) * (cols - 1);
R90 = 2 * (rows - 1) * cols;
R135 = R45;
*/
/* Normalize gray-tone spatial dependence matrix */
for (itone = 0; itone < tones; ++itone)
for (jtone = 0; jtone < tones; ++jtone)
{
P_matrix0[itone][jtone] /= R0;
P_matrix45[itone][jtone] /= R45;
P_matrix90[itone][jtone] /= R90;
P_matrix135[itone][jtone] /= R135;
}
/* fprintf (stderr, " done.)\n"); */
/* fprintf (stderr, "(Computing textural features"); */
/* fprintf (stdout, "\n"); */
/* DOT; */
/* fprintf (stdout,
"%s 0 45 90 135 Avg Range\n",
BL);
*/
if (feature_usage->ASM)
{
ASM[0] = f1_asm (P_matrix0, tones);
ASM[1] = f1_asm (P_matrix45, tones);
ASM[2] = f1_asm (P_matrix90, tones);
ASM[3] = f1_asm (P_matrix135, tones);
}
Tp = &Texture->ASM[0];
results (Tp, F1, ASM);
if (feature_usage->contrast)
{
contrast[0] = f2_contrast (P_matrix0, tones);
contrast[1] = f2_contrast (P_matrix45, tones);
contrast[2] = f2_contrast (P_matrix90, tones);
contrast[3] = f2_contrast (P_matrix135, tones);
}
Tp = &Texture->contrast[0];
results (Tp, F2, contrast);
if (feature_usage->correlation)
{
corr[0] = f3_corr (P_matrix0, tones);
corr[1] = f3_corr (P_matrix45, tones);
corr[2] = f3_corr (P_matrix90, tones);
corr[3] = f3_corr (P_matrix135, tones);
}
Tp = &Texture->correlation[0];
results (Tp, F3, corr);
if (feature_usage->variance)
{
var[0] = f4_var (P_matrix0, tones);
var[1] = f4_var (P_matrix45, tones);
var[2] = f4_var (P_matrix90, tones);
var[3] = f4_var (P_matrix135, tones);
}
Tp = &Texture->variance[0];
results (Tp, F4, var);
if (feature_usage->IDM)
{
idm[0] = f5_idm (P_matrix0, tones);
idm[1] = f5_idm (P_matrix45, tones);
idm[2] = f5_idm (P_matrix90, tones);
idm[3] = f5_idm (P_matrix135, tones);
}
Tp = &Texture->IDM[0];
results (Tp, F5, idm);
if (feature_usage->sum_avg)
{
savg[0] = f6_savg (P_matrix0, tones);
savg[1] = f6_savg (P_matrix45, tones);
savg[2] = f6_savg (P_matrix90, tones);
savg[3] = f6_savg (P_matrix135, tones);
}
Tp = &Texture->sum_avg[0];
results (Tp, F6, savg);
if (feature_usage->sum_var)
{
sentropy[0] = f8_sentropy (P_matrix0, tones);
sentropy[1] = f8_sentropy (P_matrix45, tones);
sentropy[2] = f8_sentropy (P_matrix90, tones);
sentropy[3] = f8_sentropy (P_matrix135, tones);
}
if (feature_usage->sum_entropy)
{
svar[0] = f7_svar (P_matrix0, tones, sentropy[0]);
svar[1] = f7_svar (P_matrix45, tones, sentropy[1]);
svar[2] = f7_svar (P_matrix90, tones, sentropy[2]);
svar[3] = f7_svar (P_matrix135, tones, sentropy[3]);
}
Tp = &Texture->sum_var[0];
results (Tp, F7, svar);
Tp = &Texture->sum_entropy[0];
results (Tp, F8, sentropy);
if (feature_usage->entropy)
{
entropy[0] = f9_entropy (P_matrix0, tones);
entropy[1] = f9_entropy (P_matrix45, tones);
entropy[2] = f9_entropy (P_matrix90, tones);
entropy[3] = f9_entropy (P_matrix135, tones);
}
Tp = &Texture->entropy[0];
results (Tp, F9, entropy);
if (feature_usage->diff_var)
{
dvar[0] = f10_dvar (P_matrix0, tones);
dvar[1] = f10_dvar (P_matrix45, tones);
dvar[2] = f10_dvar (P_matrix90, tones);
dvar[3] = f10_dvar (P_matrix135, tones);
}
Tp = &Texture->diff_var[0];
results (Tp, F10, dvar);
if (feature_usage->diff_entropy)
{
dentropy[0] = f11_dentropy (P_matrix0, tones);
dentropy[1] = f11_dentropy (P_matrix45, tones);
dentropy[2] = f11_dentropy (P_matrix90, tones);
dentropy[3] = f11_dentropy (P_matrix135, tones);
}
Tp = &Texture->diff_entropy[0];
results (Tp, F11, dentropy);
if (feature_usage->meas_corr1)
{
icorr[0] = f12_icorr (P_matrix0, tones);
icorr[1] = f12_icorr (P_matrix45, tones);
icorr[2] = f12_icorr (P_matrix90, tones);
icorr[3] = f12_icorr (P_matrix135, tones);
}
Tp = &Texture->meas_corr1[0];
results (Tp, F12, icorr);
if (feature_usage->meas_corr2)
{
icorr[0] = f13_icorr (P_matrix0, tones);
icorr[1] = f13_icorr (P_matrix45, tones);
icorr[2] = f13_icorr (P_matrix90, tones);
icorr[3] = f13_icorr (P_matrix135, tones);
}
Tp = &Texture->meas_corr2[0];
results (Tp, F13, icorr);
if (feature_usage->max_corr_coef)
{
maxcorr[0] = f14_maxcorr (P_matrix0, tones);
maxcorr[1] = f14_maxcorr (P_matrix45, tones);
maxcorr[2] = f14_maxcorr (P_matrix90, tones);
maxcorr[3] = f14_maxcorr (P_matrix135, tones);
}
/* M. Boland - 24 Nov 98 */
else {
maxcorr[0] = 0 ;
maxcorr[1] = 0 ;
maxcorr[2] = 0 ;
maxcorr[3] = 0 ;
}
Tp = &Texture->max_corr_coef[0];
results (Tp, F14, maxcorr);
for (i=0; i<=tones; i++) free(P_matrix0[i]);
for (i=0; i<=tones; i++) free(P_matrix45[i]);
for (i=0; i<=tones; i++) free(P_matrix90[i]);
for (i=0; i<=tones; i++) free(P_matrix135[i]);
free(P_matrix0);
free(P_matrix45);
free(P_matrix90);
free(P_matrix135);
/* fprintf (stderr, " done.)\n"); */
return (Texture);
/* exit (0);*/
}
int
main (int argc, const char ** argv) {
FILE * ifP;
gray ** grays;
unsigned int tone[PGM_MAXMAXVAL+1];
unsigned int r0, r45, r90;
unsigned int d;
unsigned int x, y;
unsigned int row;
int rows, cols;
int argn;
unsigned int itone;
unsigned int toneCt;
float ** p_matrix0, ** p_matrix45, ** p_matrix90, ** p_matrix135;
float a2m[4], contrast[4], corr[4], var[4], idm[4], savg[4];
float sentropy[4], svar[4], entropy[4], dvar[4], dentropy[4];
float icorr[4], maxcorr[4];
gray maxval;
unsigned int i;
const char * const usage = "[-d <d>] [pgmfile]";
pm_proginit(&argc, argv);
argn = 1;
/* Check for flags. */
if ( argn < argc && argv[argn][0] == '-' )
{
if ( argv[argn][1] == 'd' )
{
++argn;
if ( argn == argc || sscanf( argv[argn], "%u", &d ) != 1 )
pm_usage( usage );
}
else
pm_usage( usage );
++argn;
}
if ( argn < argc )
{
ifP = pm_openr( argv[argn] );
++argn;
}
else
ifP = stdin;
if ( argn != argc )
pm_usage( usage );
d = 1;
grays = pgm_readpgm(ifP, &cols, &rows, &maxval);
pm_close (ifP);
/* Determine the number of different gray scales (not maxval) */
for (i = 0; i <= PGM_MAXMAXVAL; ++i)
tone[i] = -1;
for (row = 0; row < rows; ++row) {
unsigned int col;
for (col = 0; col < cols; ++col)
tone[grays[row][col]] = grays[row][col];
}
for (i = 0, toneCt = 0; i <= PGM_MAXMAXVAL; ++i) {
if (tone[i] != -1)
++toneCt;
}
pm_message("(Image has %u gray levels.)", toneCt);
/* Collapse array, taking out all zero values */
for (row = 0, itone = 0; row <= PGM_MAXMAXVAL; ++row)
if (tone[row] != -1)
tone[itone++] = tone[row];
/* Now array contains only the gray levels present (in ascending order) */
/* Allocate memory for gray-tone spatial dependence matrix */
p_matrix0 = matrix (0, toneCt, 0, toneCt);
p_matrix45 = matrix (0, toneCt, 0, toneCt);
p_matrix90 = matrix (0, toneCt, 0, toneCt);
p_matrix135 = matrix (0, toneCt, 0, toneCt);
for (row = 0; row < toneCt; ++row) {
unsigned int col;
for (col = 0; col < toneCt; ++col) {
p_matrix0 [row][col] = p_matrix45 [row][col] = 0;
p_matrix90[row][col] = p_matrix135[row][col] = 0;
}
}
if (d > cols)
pm_error("Image is narrower (%u columns) "
"than specified distance (%u)", cols, d);
/* Find gray-tone spatial dependence matrix */
pm_message("Computing spatial dependence matrix...");
for (row = 0; row < rows; ++row) {
unsigned int col;
for (col = 0; col < cols; ++col) {
unsigned int angle;
for (angle = 0, x = 0; angle <= 135; angle += 45) {
while (tone[x] != grays[row][col])
++x;
if (angle == 0 && col + d < cols) {
y = 0;
while (tone[y] != grays[row][col + d])
++y;
++p_matrix0[x][y];
++p_matrix0[y][x];
}
if (angle == 90 && row + d < rows) {
y = 0;
while (tone[y] != grays[row + d][col])
++y;
++p_matrix90[x][y];
++p_matrix90[y][x];
}
if (angle == 45 && row + d < rows && col >= d) {
y = 0;
while (tone[y] != grays[row + d][col - d])
++y;
++p_matrix45[x][y];
++p_matrix45[y][x];
}
if (angle == 135 && row + d < rows && col + d < cols) {
y = 0;
while (tone[y] != grays[row + d][col + d])
++y;
++p_matrix135[x][y];
++p_matrix135[y][x];
}
}
}
}
/* Gray-tone spatial dependence matrices are complete */
/* Find normalizing constants */
r0 = 2 * rows * (cols - d);
r45 = 2 * (rows - d) * (cols - d);
r90 = 2 * (rows - d) * cols;
/* Normalize gray-tone spatial dependence matrix */
for (itone = 0; itone < toneCt; ++itone) {
unsigned int jtone;
for (jtone = 0; jtone < toneCt; ++jtone) {
p_matrix0[itone][jtone] /= r0;
p_matrix45[itone][jtone] /= r45;
p_matrix90[itone][jtone] /= r90;
p_matrix135[itone][jtone] /= r45;
}
}
pm_message(" ...done.");
pm_message("Computing textural features ...");
fprintf(stdout, "\n");
fprintf(stdout,
"%s 0 45 90 135 Avg\n",
BL);
a2m[0] = f1_a2m(p_matrix0, toneCt);
a2m[1] = f1_a2m(p_matrix45, toneCt);
a2m[2] = f1_a2m(p_matrix90, toneCt);
a2m[3] = f1_a2m(p_matrix135, toneCt);
results(F1, a2m);
contrast[0] = f2_contrast(p_matrix0, toneCt);
contrast[1] = f2_contrast(p_matrix45, toneCt);
contrast[2] = f2_contrast(p_matrix90, toneCt);
contrast[3] = f2_contrast(p_matrix135, toneCt);
results(F2, contrast);
corr[0] = f3_corr(p_matrix0, toneCt);
corr[1] = f3_corr(p_matrix45, toneCt);
corr[2] = f3_corr(p_matrix90, toneCt);
corr[3] = f3_corr(p_matrix135, toneCt);
results(F3, corr);
var[0] = f4_var(p_matrix0, toneCt);
var[1] = f4_var(p_matrix45, toneCt);
var[2] = f4_var(p_matrix90, toneCt);
var[3] = f4_var(p_matrix135, toneCt);
results(F4, var);
idm[0] = f5_idm(p_matrix0, toneCt);
idm[1] = f5_idm(p_matrix45, toneCt);
idm[2] = f5_idm(p_matrix90, toneCt);
idm[3] = f5_idm(p_matrix135, toneCt);
results(F5, idm);
savg[0] = f6_savg(p_matrix0, toneCt);
savg[1] = f6_savg(p_matrix45, toneCt);
savg[2] = f6_savg(p_matrix90, toneCt);
savg[3] = f6_savg(p_matrix135, toneCt);
results(F6, savg);
svar[0] = f7_svar(p_matrix0, toneCt, savg[0]);
svar[1] = f7_svar(p_matrix45, toneCt, savg[1]);
svar[2] = f7_svar(p_matrix90, toneCt, savg[2]);
svar[3] = f7_svar(p_matrix135, toneCt, savg[3]);
results(F7, svar);
sentropy[0] = f8_sentropy(p_matrix0, toneCt);
sentropy[1] = f8_sentropy(p_matrix45, toneCt);
sentropy[2] = f8_sentropy(p_matrix90, toneCt);
sentropy[3] = f8_sentropy(p_matrix135, toneCt);
results(F8, sentropy);
entropy[0] = f9_entropy(p_matrix0, toneCt);
entropy[1] = f9_entropy(p_matrix45, toneCt);
entropy[2] = f9_entropy(p_matrix90, toneCt);
entropy[3] = f9_entropy(p_matrix135, toneCt);
results(F9, entropy);
dvar[0] = f10_dvar(p_matrix0, toneCt);
dvar[1] = f10_dvar(p_matrix45, toneCt);
dvar[2] = f10_dvar(p_matrix90, toneCt);
dvar[3] = f10_dvar(p_matrix135, toneCt);
results(F10, dvar);
dentropy[0] = f11_dentropy(p_matrix0, toneCt);
dentropy[1] = f11_dentropy(p_matrix45, toneCt);
dentropy[2] = f11_dentropy(p_matrix90, toneCt);
dentropy[3] = f11_dentropy(p_matrix135, toneCt);
results (F11, dentropy);
icorr[0] = f12_icorr(p_matrix0, toneCt);
icorr[1] = f12_icorr(p_matrix45, toneCt);
icorr[2] = f12_icorr(p_matrix90, toneCt);
icorr[3] = f12_icorr(p_matrix135, toneCt);
results(F12, icorr);
icorr[0] = f13_icorr(p_matrix0, toneCt);
icorr[1] = f13_icorr(p_matrix45, toneCt);
icorr[2] = f13_icorr(p_matrix90, toneCt);
icorr[3] = f13_icorr(p_matrix135, toneCt);
results(F13, icorr);
maxcorr[0] = f14_maxcorr(p_matrix0, toneCt);
maxcorr[1] = f14_maxcorr(p_matrix45, toneCt);
maxcorr[2] = f14_maxcorr(p_matrix90, toneCt);
maxcorr[3] = f14_maxcorr(p_matrix135, toneCt);
results(F14, maxcorr);
pm_message(" ...done.");
return 0;
}
float h_measure(int t_m)
{
switch (t_m) {
/* Angular Second Moment */
case 1:
return (f1_asm());
break;
/* Contrast */
case 2:
return (f2_contrast());
break;
/* Correlation */
case 3:
return (f3_corr());
break;
/* Variance */
case 4:
return (f4_var());
break;
/* Inverse Diff Moment */
case 5:
return (f5_idm());
break;
/* Sum Average */
case 6:
return (f6_savg());
break;
/* Sum Variance */
case 7:
return (f7_svar());
break;
/* Sum Entropy */
case 8:
return (f8_sentropy());
break;
/* Entropy */
case 9:
return (f9_entropy());
break;
/* Difference Variance */
case 10:
return (f10_dvar());
break;
/* Difference Entropy */
case 11:
return (f11_dentropy());
break;
/* Measure of Correlation-1 */
case 12:
return (f12_icorr());
break;
/* Measure of Correlation-2 */
case 13:
return (f13_icorr());
break;
}
return 0;
}
TEXTURE * Extract_Texture_Features(int distance, int angle,
register u_int8_t **grays, int rows, int cols, int max_val)
{
int tone_LUT[PGM_MAXMAXVAL+1]; /* LUT mapping gray tone(0-255) to matrix indicies */
int tone_count=0; /* number of tones actually in the img. atleast 1 less than 255 */
int itone;
int row, col, i;
double **P_matrix;
double sum_entropy;
TEXTURE *Texture;
Texture = (TEXTURE *) calloc(1,sizeof(TEXTURE));
if (!Texture) {
printf("\nERROR in TEXTURE structure allocate\n");
exit(1);
}
/* Determine the number of different gray tones (not maxval) */
for (row = PGM_MAXMAXVAL; row >= 0; --row)
tone_LUT[row] = -1;
for (row = rows - 1; row >= 0; --row)
for (col = 0; col < cols; ++col)
tone_LUT[grays[row][col]] = grays[row][col];
for (row = PGM_MAXMAXVAL, tone_count = 0; row >= 0; --row)
if (tone_LUT[row] != -1)
tone_count++;
/* Use the number of different tones to build LUT */
for (row = 0, itone = 0; row <= PGM_MAXMAXVAL; row++)
if (tone_LUT[row] != -1)
tone_LUT[row] = itone++;
/* compute gray-tone spatial dependence matrix */
if (angle == 0)
P_matrix = CoOcMat_Angle_0 (distance, grays, rows, cols, tone_LUT, tone_count);
else if (angle == 45)
P_matrix = CoOcMat_Angle_45 (distance, grays, rows, cols, tone_LUT, tone_count);
else if (angle == 90)
P_matrix = CoOcMat_Angle_90 (distance, grays, rows, cols, tone_LUT, tone_count);
else if (angle == 135)
P_matrix = CoOcMat_Angle_135 (distance, grays, rows, cols, tone_LUT, tone_count);
else {
fprintf (stderr, "Cannot created co-occurence matrix for angle %d. Unsupported angle.\n", angle);
return NULL;
}
/* compute the statistics for the spatial dependence matrix */
Texture->ASM = f1_asm (P_matrix, tone_count);
Texture->contrast = f2_contrast (P_matrix, tone_count);
Texture->correlation = f3_corr (P_matrix, tone_count);
Texture->variance = f4_var (P_matrix, tone_count);
Texture->IDM = f5_idm (P_matrix, tone_count);
Texture->sum_avg = f6_savg (P_matrix, tone_count);
/* T.J.M watch below the cast from float to double */
sum_entropy = f8_sentropy (P_matrix, tone_count);
Texture->sum_entropy = sum_entropy;
Texture->sum_var = f7_svar (P_matrix, tone_count, sum_entropy);
Texture->entropy = f9_entropy (P_matrix, tone_count);
Texture->diff_var = f10_dvar (P_matrix, tone_count);
Texture->diff_entropy = f11_dentropy (P_matrix, tone_count);
Texture->meas_corr1 = f12_icorr (P_matrix, tone_count);
Texture->meas_corr2 = f13_icorr (P_matrix, tone_count);
Texture->max_corr_coef = f14_maxcorr (P_matrix, tone_count);
return (Texture);
}
